List<T> Sınıf

Tanım

Dizin tarafından erişilebilen, türü kesin belirlenmiş bir nesne listesini temsil eder.Represents a strongly typed list of objects that can be accessed by index. Listeleri aramak, sıralamak ve işlemek için yöntemler sağlar.Provides methods to search, sort, and manipulate lists.

generic <typename T>
public ref class List : System::Collections::Generic::ICollection<T>, System::Collections::Generic::IEnumerable<T>, System::Collections::Generic::IList<T>, System::Collections::Generic::IReadOnlyCollection<T>, System::Collections::Generic::IReadOnlyList<T>, System::Collections::IList
generic <typename T>
public ref class List : System::Collections::Generic::ICollection<T>, System::Collections::Generic::IEnumerable<T>, System::Collections::Generic::IList<T>, System::Collections::IList
public class List<T> : System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IList<T>, System.Collections.Generic.IReadOnlyCollection<T>, System.Collections.Generic.IReadOnlyList<T>, System.Collections.IList
[System.Serializable]
public class List<T> : System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IList<T>, System.Collections.IList
[System.Serializable]
public class List<T> : System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IList<T>, System.Collections.Generic.IReadOnlyCollection<T>, System.Collections.Generic.IReadOnlyList<T>, System.Collections.IList
type List<'T> = class
    interface ICollection<'T>
    interface seq<'T>
    interface IEnumerable
    interface IList<'T>
    interface IReadOnlyCollection<'T>
    interface IReadOnlyList<'T>
    interface ICollection
    interface IList
[<System.Serializable>]
type List<'T> = class
    interface IList<'T>
    interface ICollection<'T>
    interface seq<'T>
    interface IList
    interface ICollection
    interface IEnumerable
[<System.Serializable>]
type List<'T> = class
    interface IList<'T>
    interface ICollection<'T>
    interface IList
    interface ICollection
    interface IReadOnlyList<'T>
    interface IReadOnlyCollection<'T>
    interface seq<'T>
    interface IEnumerable
[<System.Serializable>]
type List<'T> = class
    interface IList<'T>
    interface ICollection<'T>
    interface seq<'T>
    interface IEnumerable
    interface IList
    interface ICollection
    interface IReadOnlyList<'T>
    interface IReadOnlyCollection<'T>
type List<'T> = class
    interface IList<'T>
    interface ICollection<'T>
    interface IReadOnlyList<'T>
    interface IReadOnlyCollection<'T>
    interface seq<'T>
    interface IList
    interface ICollection
    interface IEnumerable
[<System.Serializable>]
type List<'T> = class
    interface IList<'T>
    interface IList
    interface IReadOnlyList<'T>
    interface ICollection<'T>
    interface seq<'T>
    interface IEnumerable
    interface ICollection
    interface IReadOnlyCollection<'T>
Public Class List(Of T)
Implements ICollection(Of T), IEnumerable(Of T), IList, IList(Of T), IReadOnlyCollection(Of T), IReadOnlyList(Of T)
Public Class List(Of T)
Implements ICollection(Of T), IEnumerable(Of T), IList, IList(Of T)

Tür Parametreleri

T

Listedeki öğelerin türü.The type of elements in the list.

Devralma
List<T>
Türetilmiş
Öznitelikler
Uygulamalar

Örnekler

Aşağıdaki örnek, içinde basit bir iş nesnesinin nasıl ekleneceğini, kaldırılacağını ve ekleneceğini gösterir List<T> .The following example demonstrates how to add, remove, and insert a simple business object in a List<T>.

using System;
using System.Collections.Generic;
// Simple business object. A PartId is used to identify the type of part
// but the part name can change.
public class Part : IEquatable<Part>
    {
        public string PartName { get; set; }

        public int PartId { get; set; }

        public override string ToString()
        {
            return "ID: " + PartId + "   Name: " + PartName;
        }
        public override bool Equals(object obj)
        {
            if (obj == null) return false;
            Part objAsPart = obj as Part;
            if (objAsPart == null) return false;
            else return Equals(objAsPart);
        }
        public override int GetHashCode()
        {
            return PartId;
        }
        public bool Equals(Part other)
        {
            if (other == null) return false;
            return (this.PartId.Equals(other.PartId));
        }
    // Should also override == and != operators.
    }
public class Example
{
    public static void Main()
    {
        // Create a list of parts.
        List<Part> parts = new List<Part>();

        // Add parts to the list.
        parts.Add(new Part() {PartName="crank arm", PartId=1234});
        parts.Add(new Part() { PartName = "chain ring", PartId = 1334 });
        parts.Add(new Part() { PartName = "regular seat", PartId = 1434 });
        parts.Add(new Part() { PartName = "banana seat", PartId = 1444 });
        parts.Add(new Part() { PartName = "cassette", PartId = 1534 });
        parts.Add(new Part() { PartName = "shift lever", PartId = 1634 });

        // Write out the parts in the list. This will call the overridden ToString method
        // in the Part class.
        Console.WriteLine();
        foreach (Part aPart in parts)
        {
            Console.WriteLine(aPart);
        }

        // Check the list for part #1734. This calls the IEquatable.Equals method
        // of the Part class, which checks the PartId for equality.
        Console.WriteLine("\nContains(\"1734\"): {0}",
        parts.Contains(new Part {PartId=1734, PartName="" }));

        // Insert a new item at position 2.
        Console.WriteLine("\nInsert(2, \"1834\")");
        parts.Insert(2, new Part() { PartName = "brake lever", PartId = 1834 });

        //Console.WriteLine();
        foreach (Part aPart in parts)
        {
            Console.WriteLine(aPart);
        }

        Console.WriteLine("\nParts[3]: {0}", parts[3]);

        Console.WriteLine("\nRemove(\"1534\")");

        // This will remove part 1534 even though the PartName is different,
        // because the Equals method only checks PartId for equality.
        parts.Remove(new Part(){PartId=1534, PartName="cogs"});

        Console.WriteLine();
        foreach (Part aPart in parts)
        {
            Console.WriteLine(aPart);
        }
        Console.WriteLine("\nRemoveAt(3)");
        // This will remove the part at index 3.
        parts.RemoveAt(3);

        Console.WriteLine();
        foreach (Part aPart in parts)
        {
            Console.WriteLine(aPart);
        }

            /*

             ID: 1234   Name: crank arm
             ID: 1334   Name: chain ring
             ID: 1434   Name: regular seat
             ID: 1444   Name: banana seat
             ID: 1534   Name: cassette
             ID: 1634   Name: shift lever

             Contains("1734"): False

             Insert(2, "1834")
             ID: 1234   Name: crank arm
             ID: 1334   Name: chain ring
             ID: 1834   Name: brake lever
             ID: 1434   Name: regular seat
             ID: 1444   Name: banana seat
             ID: 1534   Name: cassette
             ID: 1634   Name: shift lever

             Parts[3]: ID: 1434   Name: regular seat

             Remove("1534")

             ID: 1234   Name: crank arm
             ID: 1334   Name: chain ring
             ID: 1834   Name: brake lever
             ID: 1434   Name: regular seat
             ID: 1444   Name: banana seat
             ID: 1634   Name: shift lever

             RemoveAt(3)

             ID: 1234   Name: crank arm
             ID: 1334   Name: chain ring
             ID: 1834   Name: brake lever
             ID: 1444   Name: banana seat
             ID: 1634   Name: shift lever


         */
    }
}
Imports System.Collections.Generic

' Simple business object. A PartId is used to identify the type of part 
' but the part name can change. 
Public Class Part
    Implements IEquatable(Of Part)
    Public Property PartName() As String
        Get
            Return m_PartName
        End Get
        Set(value As String)
            m_PartName = Value
        End Set
    End Property
    Private m_PartName As String

    Public Property PartId() As Integer
        Get
            Return m_PartId
        End Get
        Set(value As Integer)
            m_PartId = Value
        End Set
    End Property
    Private m_PartId As Integer

    Public Overrides Function ToString() As String
        Return "ID: " & PartId & "   Name: " & PartName
    End Function
    Public Overrides Function Equals(obj As Object) As Boolean
        If obj Is Nothing Then
            Return False
        End If
        Dim objAsPart As Part = TryCast(obj, Part)
        If objAsPart Is Nothing Then
            Return False
        Else
            Return Equals(objAsPart)
        End If
    End Function
    Public Overrides Function GetHashCode() As Integer
        Return PartId
    End Function
    Public Overloads Function Equals(other As Part) As Boolean _
        Implements IEquatable(Of Part).Equals
        If other Is Nothing Then
            Return False
        End If
        Return (Me.PartId.Equals(other.PartId))
    End Function
    ' Should also override == and != operators.

End Class
Public Class Example
    Public Shared Sub Main()
        ' Create a list of parts.
        Dim parts As New List(Of Part)()

        ' Add parts to the list.
        parts.Add(New Part() With { _
             .PartName = "crank arm", _
             .PartId = 1234 _
        })
        parts.Add(New Part() With { _
             .PartName = "chain ring", _
             .PartId = 1334 _
        })
        parts.Add(New Part() With { _
             .PartName = "regular seat", _
             .PartId = 1434 _
        })
        parts.Add(New Part() With { _
             .PartName = "banana seat", _
             .PartId = 1444 _
        })
        parts.Add(New Part() With { _
             .PartName = "cassette", _
             .PartId = 1534 _
        })
        parts.Add(New Part() With { _
             .PartName = "shift lever", _
             .PartId = 1634 _
        })



        ' Write out the parts in the list. This will call the overridden ToString method
        ' in the Part class.
        Console.WriteLine()
        For Each aPart As Part In parts
            Console.WriteLine(aPart)
        Next


        ' Check the list for part #1734. This calls the IEquatable.Equals method
        ' of the Part class, which checks the PartId for equality.
        Console.WriteLine(vbLf & "Contains(""1734""): {0}", parts.Contains(New Part() With { _
             .PartId = 1734, _
             .PartName = "" _
        }))

        ' Insert a new item at position 2.
        Console.WriteLine(vbLf & "Insert(2, ""1834"")")
        parts.Insert(2, New Part() With { _
             .PartName = "brake lever", _
             .PartId = 1834 _
        })


        'Console.WriteLine();
        For Each aPart As Part In parts
            Console.WriteLine(aPart)
        Next

        Console.WriteLine(vbLf & "Parts[3]: {0}", parts(3))

        Console.WriteLine(vbLf & "Remove(""1534"")")

        ' This will remove part 1534 even though the PartName is different,
        ' because the Equals method only checks PartId for equality.
        parts.Remove(New Part() With { _
             .PartId = 1534, _
             .PartName = "cogs" _
        })

        Console.WriteLine()
        For Each aPart As Part In parts
            Console.WriteLine(aPart)
        Next

        Console.WriteLine(vbLf & "RemoveAt(3)")
        ' This will remove part at index 3.
        parts.RemoveAt(3)

        Console.WriteLine()
        For Each aPart As Part In parts
            Console.WriteLine(aPart)
        Next
    End Sub
    '
    '        This example code produces the following output:
    '        ID: 1234   Name: crank arm
    '        ID: 1334   Name: chain ring
    '        ID: 1434   Name: regular seat
    '        ID: 1444   Name: banana seat
    '        ID: 1534   Name: cassette
    '        ID: 1634   Name: shift lever
    '
    '        Contains("1734"): False
    '
    '        Insert(2, "1834")
    '        ID: 1234   Name: crank arm
    '        ID: 1334   Name: chain ring
    '        ID: 1834   Name: brake lever
    '        ID: 1434   Name: regular seat
    '        ID: 1444   Name: banana seat
    '        ID: 1534   Name: cassette
    '        ID: 1634   Name: shift lever
    '
    '        Parts[3]: ID: 1434   Name: regular seat
    '
    '        Remove("1534")
    '
    '        ID: 1234   Name: crank arm
    '        ID: 1334   Name: chain ring
    '        ID: 1834   Name: brake lever
    '        ID: 1434   Name: regular seat
    '        ID: 1444   Name: banana seat
    '        ID: 1634   Name: shift lever
    '   '
    '        RemoveAt(3)
    '
    '        ID: 1234   Name: crank arm
    '        ID: 1334   Name: chain ring
    '        ID: 1834   Name: brake lever
    '        ID: 1444   Name: banana seat
    '        ID: 1634   Name: shift lever
    '        

End Class

// Simple business object. A PartId is used to identify the type of part  
// but the part name can change.  
[<CustomEquality; NoComparison>]
type Part = { PartId : int ; mutable PartName : string } with
    override this.GetHashCode() = hash this.PartId
    override this.Equals(other) =
        match other with
        | :? Part as p -> this.PartId = p.PartId
        | _ -> false
    override this.ToString() = sprintf "ID: %i   Name: %s" this.PartId this.PartName

[<EntryPoint>]
let main argv = 
    // We refer to System.Collections.Generic.List<'T> by its type 
    // abbreviation ResizeArray<'T> to avoid conflicts with the F# List module.    
    // Note: In F# code, F# linked lists are usually preferred over
    // ResizeArray<'T> when an extendable collection is required.
    let parts = ResizeArray<_>()
    parts.Add({PartName = "crank arm" ; PartId = 1234})
    parts.Add({PartName = "chain ring"; PartId = 1334 })
    parts.Add({PartName = "regular seat"; PartId = 1434 })
    parts.Add({PartName = "banana seat"; PartId = 1444 })
    parts.Add({PartName = "cassette"; PartId = 1534 })
    parts.Add({PartName = "shift lever"; PartId = 1634 })

    // Write out the parts in the ResizeArray.  This will call the overridden ToString method
    // in the Part type
    printfn ""
    parts |> Seq.iter (fun p -> printfn "%O" p)

    // Check the ResizeArray for part #1734. This calls the IEquatable.Equals method 
    // of the Part type, which checks the PartId for equality.    
    printfn "\nContains(\"1734\"): %b" (parts.Contains({PartId=1734; PartName=""}))
    
    // Insert a new item at position 2.
    printfn "\nInsert(2, \"1834\")"
    parts.Insert(2, { PartName = "brake lever"; PartId = 1834 })

    // Write out all parts
    parts |> Seq.iter (fun p -> printfn "%O" p)

    printfn "\nParts[3]: %O" parts.[3]

    printfn "\nRemove(\"1534\")"
    // This will remove part 1534 even though the PartName is different, 
    // because the Equals method only checks PartId for equality.
    // Since Remove returns true or false, we need to ignore the result
    parts.Remove({PartId=1534; PartName="cogs"}) |> ignore

    // Write out all parts
    printfn ""
    parts |> Seq.iter (fun p -> printfn "%O" p)

    printfn "\nRemoveAt(3)"
    // This will remove the part at index 3.
    parts.RemoveAt(3)

    // Write out all parts
    printfn ""
    parts |> Seq.iter (fun p -> printfn "%O" p)

    0 // return an integer exit code

Aşağıdaki örnek, List<T> dize türünde genel sınıfın bazı özelliklerini ve yöntemlerini gösterir.The following example demonstrates several properties and methods of the List<T> generic class of type string. (Karmaşık türlerin bir örneği için List<T> bkz Contains . yöntemi.)(For an example of a List<T> of complex types, see the Contains method.)

Parametresiz Oluşturucu, varsayılan kapasiteye sahip dizelerin bir listesini oluşturmak için kullanılır.The parameterless constructor is used to create a list of strings with the default capacity. CapacityÖzelliği görüntülenir ve daha sonra Add yöntemi birkaç öğe eklemek için kullanılır.The Capacity property is displayed and then the Add method is used to add several items. Öğelerin Capacity Count gerektiği şekilde arttığını göstermek için öğeler listelenir ve özelliği özelliği ile birlikte görüntülenir.The items are listed, and the Capacity property is displayed again, along with the Count property, to show that the capacity has been increased as needed.

ContainsYöntemi, listedeki bir öğenin varlığını test etmek için kullanılır, Insert yöntemi listenin ortasına yeni bir öğe eklemek için kullanılır ve listenin içeriği yeniden görüntülenir.The Contains method is used to test for the presence of an item in the list, the Insert method is used to insert a new item in the middle of the list, and the contents of the list are displayed again.

Varsayılan Item[] Özellik (C# ' deki Dizin Oluşturucu) bir öğeyi almak için kullanılırsa, Remove yöntemi daha önce eklenen yinelenen öğenin ilk örneğini kaldırmak için kullanılır ve içerik yeniden görüntülenir.The default Item[] property (the indexer in C#) is used to retrieve an item, the Remove method is used to remove the first instance of the duplicate item added earlier, and the contents are displayed again. RemoveYöntemi her zaman karşılaştığı ilk örneği kaldırır.The Remove method always removes the first instance it encounters.

TrimExcessYöntemi, sayımla eşleşecek kapasiteyi azaltmak için kullanılır ve Capacity ve Count özellikleri görüntülenir.The TrimExcess method is used to reduce the capacity to match the count, and the Capacity and Count properties are displayed. Kullanılmayan Kapasite toplam kapasitenin yüzde 10 ' dan az olsaydı, liste yeniden boyutlandırılmaz.If the unused capacity had been less than 10 percent of total capacity, the list would not have been resized.

Son olarak, Clear yöntemi listedeki tüm öğeleri kaldırmak için kullanılır ve Capacity ve Count özellikleri görüntülenir.Finally, the Clear method is used to remove all items from the list, and the Capacity and Count properties are displayed.

using namespace System;
using namespace System::Collections::Generic;

void main()
{
    List<String^>^ dinosaurs = gcnew List<String^>();

    Console::WriteLine("\nCapacity: {0}", dinosaurs->Capacity);

    dinosaurs->Add("Tyrannosaurus");
    dinosaurs->Add("Amargasaurus");
    dinosaurs->Add("Mamenchisaurus");
    dinosaurs->Add("Deinonychus");
    dinosaurs->Add("Compsognathus");

    Console::WriteLine();
    for each(String^ dinosaur in dinosaurs )
    {
        Console::WriteLine(dinosaur);
    }

    Console::WriteLine("\nCapacity: {0}", dinosaurs->Capacity);
    Console::WriteLine("Count: {0}", dinosaurs->Count);

    Console::WriteLine("\nContains(\"Deinonychus\"): {0}",
        dinosaurs->Contains("Deinonychus"));

    Console::WriteLine("\nInsert(2, \"Compsognathus\")");
    dinosaurs->Insert(2, "Compsognathus");

    Console::WriteLine();
    for each(String^ dinosaur in dinosaurs )
    {
        Console::WriteLine(dinosaur);
    }

    Console::WriteLine("\ndinosaurs[3]: {0}", dinosaurs[3]);

    Console::WriteLine("\nRemove(\"Compsognathus\")");
    dinosaurs->Remove("Compsognathus");

    Console::WriteLine();
    for each(String^ dinosaur in dinosaurs )
    {
        Console::WriteLine(dinosaur);
    }

    dinosaurs->TrimExcess();
    Console::WriteLine("\nTrimExcess()");
    Console::WriteLine("Capacity: {0}", dinosaurs->Capacity);
    Console::WriteLine("Count: {0}", dinosaurs->Count);

    dinosaurs->Clear();
    Console::WriteLine("\nClear()");
    Console::WriteLine("Capacity: {0}", dinosaurs->Capacity);
    Console::WriteLine("Count: {0}", dinosaurs->Count);
}

/* This code example produces the following output:

Capacity: 0

Tyrannosaurus
Amargasaurus
Mamenchisaurus
Deinonychus
Compsognathus

Capacity: 8
Count: 5

Contains("Deinonychus"): True

Insert(2, "Compsognathus")

Tyrannosaurus
Amargasaurus
Compsognathus
Mamenchisaurus
Deinonychus
Compsognathus

dinosaurs[3]: Mamenchisaurus

Remove("Compsognathus")

Tyrannosaurus
Amargasaurus
Mamenchisaurus
Deinonychus
Compsognathus

TrimExcess()
Capacity: 5
Count: 5

Clear()
Capacity: 5
Count: 0
 */
List<string> dinosaurs = new List<string>();

Console.WriteLine("\nCapacity: {0}", dinosaurs.Capacity);

dinosaurs.Add("Tyrannosaurus");
dinosaurs.Add("Amargasaurus");
dinosaurs.Add("Mamenchisaurus");
dinosaurs.Add("Deinonychus");
dinosaurs.Add("Compsognathus");
Console.WriteLine();
foreach(string dinosaur in dinosaurs)
{
    Console.WriteLine(dinosaur);
}

Console.WriteLine("\nCapacity: {0}", dinosaurs.Capacity);
Console.WriteLine("Count: {0}", dinosaurs.Count);

Console.WriteLine("\nContains(\"Deinonychus\"): {0}",
    dinosaurs.Contains("Deinonychus"));

Console.WriteLine("\nInsert(2, \"Compsognathus\")");
dinosaurs.Insert(2, "Compsognathus");

Console.WriteLine();
foreach(string dinosaur in dinosaurs)
{
    Console.WriteLine(dinosaur);
}

// Shows accessing the list using the Item property.
Console.WriteLine("\ndinosaurs[3]: {0}", dinosaurs[3]);

Console.WriteLine("\nRemove(\"Compsognathus\")");
dinosaurs.Remove("Compsognathus");

Console.WriteLine();
foreach(string dinosaur in dinosaurs)
{
    Console.WriteLine(dinosaur);
}

dinosaurs.TrimExcess();
Console.WriteLine("\nTrimExcess()");
Console.WriteLine("Capacity: {0}", dinosaurs.Capacity);
Console.WriteLine("Count: {0}", dinosaurs.Count);

dinosaurs.Clear();
Console.WriteLine("\nClear()");
Console.WriteLine("Capacity: {0}", dinosaurs.Capacity);
Console.WriteLine("Count: {0}", dinosaurs.Count);

/* This code example produces the following output:

Capacity: 0

Tyrannosaurus
Amargasaurus
Mamenchisaurus
Deinonychus
Compsognathus

Capacity: 8
Count: 5

Contains("Deinonychus"): True

Insert(2, "Compsognathus")

Tyrannosaurus
Amargasaurus
Compsognathus
Mamenchisaurus
Deinonychus
Compsognathus

dinosaurs[3]: Mamenchisaurus

Remove("Compsognathus")

Tyrannosaurus
Amargasaurus
Mamenchisaurus
Deinonychus
Compsognathus

TrimExcess()
Capacity: 5
Count: 5

Clear()
Capacity: 5
Count: 0
 */
Imports System.Collections.Generic

Public Class Example

    Public Shared Sub Main()
        Dim dinosaurs As New List(Of String)

        Console.WriteLine(vbLf & "Capacity: {0}", dinosaurs.Capacity)

        dinosaurs.Add("Tyrannosaurus")
        dinosaurs.Add("Amargasaurus")
        dinosaurs.Add("Mamenchisaurus")
        dinosaurs.Add("Deinonychus")
        dinosaurs.Add("Compsognathus")

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

        Console.WriteLine(vbLf & "Capacity: {0}", dinosaurs.Capacity)
        Console.WriteLine("Count: {0}", dinosaurs.Count)

        Console.WriteLine(vbLf & "Contains(""Deinonychus""): {0}", _
            dinosaurs.Contains("Deinonychus"))

        Console.WriteLine(vbLf & "Insert(2, ""Compsognathus"")")
        dinosaurs.Insert(2, "Compsognathus")

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next
        ' Shows how to access the list using the Item property.
        Console.WriteLine(vbLf & "dinosaurs(3): {0}", dinosaurs(3))
        Console.WriteLine(vbLf & "Remove(""Compsognathus"")")
        dinosaurs.Remove("Compsognathus")

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

        dinosaurs.TrimExcess()
        Console.WriteLine(vbLf & "TrimExcess()")
        Console.WriteLine("Capacity: {0}", dinosaurs.Capacity)
        Console.WriteLine("Count: {0}", dinosaurs.Count)

        dinosaurs.Clear()
        Console.WriteLine(vbLf & "Clear()")
        Console.WriteLine("Capacity: {0}", dinosaurs.Capacity)
        Console.WriteLine("Count: {0}", dinosaurs.Count)
    End Sub
End Class

' This code example produces the following output:
'
'Capacity: 0
'
'Tyrannosaurus
'Amargasaurus
'Mamenchisaurus
'Deinonychus
'Compsognathus
'
'Capacity: 8
'Count: 5
'
'Contains("Deinonychus"): True
'
'Insert(2, "Compsognathus")
'
'Tyrannosaurus
'Amargasaurus
'Compsognathus
'Mamenchisaurus
'Deinonychus
'Compsognathus
'
'dinosaurs(3): Mamenchisaurus
'
'Remove("Compsognathus")
'
'Tyrannosaurus
'Amargasaurus
'Mamenchisaurus
'Deinonychus
'Compsognathus
'
'TrimExcess()
'Capacity: 5
'Count: 5
'
'Clear()
'Capacity: 5
'Count: 0

[<EntryPoint>]
let main argv = 
    // We refer to System.Collections.Generic.List<'T> by its type 
    // abbreviation ResizeArray<'T> to avoid conflict with the List module.    
    // Note: In F# code, F# linked lists are usually preferred over
    // ResizeArray<'T> when an extendable collection is required.
    let dinosaurs = ResizeArray<_>()
 
    // Write out the dinosaurs in the ResizeArray.
    let printDinosaurs() =
        printfn ""
        dinosaurs |> Seq.iter (fun p -> printfn "%O" p) 
 
    
    printfn "\nCapacity: %i" dinosaurs.Capacity
 
    dinosaurs.Add("Tyrannosaurus")
    dinosaurs.Add("Amargasaurus")
    dinosaurs.Add("Mamenchisaurus")
    dinosaurs.Add("Deinonychus")
    dinosaurs.Add("Compsognathus")
 
    printDinosaurs()
 
    printfn "\nCapacity: %i" dinosaurs.Capacity
    printfn "Count: %i" dinosaurs.Count
 
    printfn "\nContains(\"Deinonychus\"): %b" (dinosaurs.Contains("Deinonychus"))
 
    printfn "\nInsert(2, \"Compsognathus\")"
    dinosaurs.Insert(2, "Compsognathus")
 
    printDinosaurs()
 
    // Shows accessing the list using the Item property.
    printfn "\ndinosaurs[3]: %s" dinosaurs.[3]
 
    printfn "\nRemove(\"Compsognathus\")"
    dinosaurs.Remove("Compsognathus") |> ignore
 
    printDinosaurs()
 
    dinosaurs.TrimExcess()
    printfn "\nTrimExcess()"
    printfn "Capacity: %i" dinosaurs.Capacity
    printfn "Count: %i" dinosaurs.Count
 
    dinosaurs.Clear()
    printfn "\nClear()"
    printfn "Capacity: %i" dinosaurs.Capacity
    printfn "Count: %i" dinosaurs.Count
 
    0 // return an integer exit code
 
    (* This code example produces the following output:
 
Capacity: 0
 
Tyrannosaurus
Amargasaurus
Mamenchisaurus
Deinonychus
Compsognathus
 
Capacity: 8
Count: 5
 
Contains("Deinonychus"): true
 
Insert(2, "Compsognathus")
 
Tyrannosaurus
Amargasaurus
Compsognathus
Mamenchisaurus
Deinonychus
Compsognathus
 
dinosaurs[3]: Mamenchisaurus
 
Remove("Compsognathus")
 
Tyrannosaurus
Amargasaurus
Mamenchisaurus
Deinonychus
Compsognathus
 
TrimExcess()
Capacity: 5
Count: 5
 
Clear()
Capacity: 5
Count: 0
    *)

Açıklamalar

List<T>Sınıfı, sınıfının genel eşdeğeridir ArrayList .The List<T> class is the generic equivalent of the ArrayList class. IList<T>Boyutu dinamik olarak gerektiği şekilde arttığı bir diziyi kullanarak genel arabirimi uygular.It implements the IList<T> generic interface by using an array whose size is dynamically increased as required.

List<T>Veya yöntemlerini kullanarak öğesine öğe ekleyebilirsiniz Add AddRange .You can add items to a List<T> by using the Add or AddRange methods.

List<T>Sınıfı hem eşitlik karşılaştırıcısı hem de bir sıralama karşılaştırıcısı kullanır.The List<T> class uses both an equality comparer and an ordering comparer.

  • ,, Contains Ve gibi IndexOf Yöntemler LastIndexOf Remove liste öğeleri için eşitlik karşılaştırıcısı kullanır.Methods such as Contains, IndexOf, LastIndexOf, and Remove use an equality comparer for the list elements. Türü için varsayılan eşitlik karşılaştırıcısı T aşağıdaki gibi belirlenir.The default equality comparer for type T is determined as follows. Tür T IEquatable<T> genel arabirimi uyguluyorsa, eşitlik karşılaştırıcısı Equals(T) Bu arabirimin yöntemidir; Aksi takdirde varsayılan eşitlik karşılaştırıcısı olur Object.Equals(Object) .If type T implements the IEquatable<T> generic interface, then the equality comparer is the Equals(T) method of that interface; otherwise, the default equality comparer is Object.Equals(Object).

  • Ve gibi yöntemler BinarySearch Sort liste öğeleri için bir sıralama karşılaştırıcısı kullanır.Methods such as BinarySearch and Sort use an ordering comparer for the list elements. Tür için varsayılan karşılaştırıcı T aşağıdaki gibi belirlenir.The default comparer for type T is determined as follows. Tür T IComparable<T> genel arabirimi uyguluyorsa, varsayılan karşılaştırıcı CompareTo(T) Bu arabirimin yöntemidir; Aksi takdirde, tür T genel olmayan arabirimi uygularsa, IComparable varsayılan karşılaştırıcı CompareTo(Object) Bu arabirimin yöntemidir.If type T implements the IComparable<T> generic interface, then the default comparer is the CompareTo(T) method of that interface; otherwise, if type T implements the nongeneric IComparable interface, then the default comparer is the CompareTo(Object) method of that interface. Tür hiçbir T arabirim uygularsa, varsayılan karşılaştırıcı yoktur ve açıkça bir karşılaştırıcı veya karşılaştırma temsilcisi sağlanmalıdır.If type T implements neither interface, then there is no default comparer, and a comparer or comparison delegate must be provided explicitly.

List<T>Sıralanabilecek garanti edilmez.The List<T> is not guaranteed to be sorted. ' Nin List<T> sıralanmasını gerektiren işlemleri (gibi) öncelikle sıralama yapmanız gerekir BinarySearch List<T> .You must sort the List<T> before performing operations (such as BinarySearch) that require the List<T> to be sorted.

Bu koleksiyondaki öğelere bir tamsayı dizin kullanılarak erişilebilir.Elements in this collection can be accessed using an integer index. Bu koleksiyondaki dizinler sıfır tabanlıdır.Indexes in this collection are zero-based.

Yalnızca .NET Framework: Çok büyük List<T> nesneler için, enabled <gcAllowVeryLargeObjects> yapılandırma öğesinin özniteliğini true çalışma zamanı ortamında olarak ayarlayarak 64 bit sistemdeki en fazla 2.000.000.000 öğeye kapasiteyi artırabilirsiniz..NET Framework only: For very large List<T> objects, you can increase the maximum capacity to 2 billion elements on a 64-bit system by setting the enabled attribute of the <gcAllowVeryLargeObjects> configuration element to true in the run-time environment.

List<T>nullbaşvuru türleri için geçerli bir değer olarak kabul eder ve yinelenen öğelere izin verir.List<T> accepts null as a valid value for reference types and allows duplicate elements.

Sınıfının sabit bir sürümü için List<T> bkz ImmutableList<T> ..For an immutable version of the List<T> class, see ImmutableList<T>.

Başarım DeğerlendirmeleriPerformance Considerations

List<T> ArrayList Her ikisi de benzer işlevselliğe sahip olan veya sınıfının kullanılmasına karar verirken, List<T> sınıfın çoğu durumda daha iyi performans ve tür kullanımı güvenli olduğunu unutmayın.In deciding whether to use the List<T> or ArrayList class, both of which have similar functionality, remember that the List<T> class performs better in most cases and is type safe. Sınıf türü için bir başvuru türü kullanılırsa T List<T> , iki sınıfın davranışı özdeştir.If a reference type is used for type T of the List<T> class, the behavior of the two classes is identical. Ancak, tür için bir değer türü kullanılırsa T , uygulama ve paketleme sorunlarını dikkate almanız gerekir.However, if a value type is used for type T, you need to consider implementation and boxing issues.

Tür için bir değer türü kullanılırsa T , derleyici List<T> Bu değer türü için özel olarak sınıfın bir uygulamasını oluşturur.If a value type is used for type T, the compiler generates an implementation of the List<T> class specifically for that value type. Diğer bir deyişle, bir nesnenin liste öğesi List<T> , öğe kullanılmadan önce kutulanmamalıdır ve 500 liste öğeleri oluşturulduktan sonra, paketleme listesi öğeleri oluşturulduktan sonra, sınıf uygulamasını oluşturmak için kullanılan bellekten daha büyüktür.That means a list element of a List<T> object does not have to be boxed before the element can be used, and after about 500 list elements are created the memory saved not boxing list elements is greater than the memory used to generate the class implementation.

Tür için kullanılan değer türünün T genel arabirimi uyguladığından emin olun IEquatable<T> .Make certain the value type used for type T implements the IEquatable<T> generic interface. Aksi takdirde, gibi yöntemler Contains Object.Equals(Object) etkilenen liste öğesini kutulara yöntemini çağırmalıdır.If not, methods such as Contains must call the Object.Equals(Object) method, which boxes the affected list element. Değer türü arabirimini uyguluyorsa IComparable ve kaynak koda sahipseniz, IComparable<T> BinarySearch ve yöntemlerinin kutulanmaı liste öğelerinden oluşmasını engellemek için genel arabirimi de uygulayın Sort .If the value type implements the IComparable interface and you own the source code, also implement the IComparable<T> generic interface to prevent the BinarySearch and Sort methods from boxing list elements. Kaynak koda sahip değilseniz IComparer<T> BinarySearch ve yöntemlerine bir nesne geçirin SortIf you do not own the source code, pass an IComparer<T> object to the BinarySearch and Sort methods

Sınıfı List<T> kullanmak ArrayList veya kesin türü belirtilmiş bir sarmalayıcı koleksiyonu yazmak yerine, sınıfının türüne özgü uygulamasını kullanmak sizin avantajınıza ait.It is to your advantage to use the type-specific implementation of the List<T> class instead of using the ArrayList class or writing a strongly typed wrapper collection yourself. Bunun nedeni, uygulamanızın zaten .NET Framework ne yaptığını yapması gerekir ve ortak dil çalışma zamanı, uygulamanızın yapamayacağı Microsoft ara dil kodunu ve meta verileri paylaşabilir.The reason is your implementation must do what the .NET Framework does for you already, and the common language runtime can share Microsoft intermediate language code and metadata, which your implementation cannot.

F # konularıF# Considerations

List<T>Sınıfı, F # kodunda seyrek kullanılır.The List<T> class is used infrequently in F# code. Bunun yerine, sabit, listedir bağlantılı listeler olan listelergenellikle tercih edilir.Instead, Lists, which are immutable, singly-linked lists, are typically preferred. Bir F # listesi sıralı, sabit bir değer serisi sağlar ve işlevsel stil geliştirmede kullanılmak üzere desteklenir.An F# List provides an ordered, immutable series of values, and is supported for use in functional-style development. F # ' dan kullanıldığında, List<T> f # listeleriyle adlandırma çakışmalarını önlemek için, sınıfına genellikle ResizeArray <'T> türü kısaltması başvurulur.When used from F#, the List<T> class is typically referred to by the ResizeArray<'T> type abbreviation to avoid naming conflicts with F# Lists.

Oluşturucular

List<T>()

Boş bir sınıfının yeni bir örneğini başlatır List<T> ve varsayılan ilk kapasiteye sahiptir.Initializes a new instance of the List<T> class that is empty and has the default initial capacity.

List<T>(IEnumerable<T>)

List<T>Belirtilen koleksiyondan kopyalanmış öğeleri içeren ve ' ın kopyalandığı öğe sayısına yetecek kapasiteye sahip olan sınıfın yeni bir örneğini başlatır.Initializes a new instance of the List<T> class that contains elements copied from the specified collection and has sufficient capacity to accommodate the number of elements copied.

List<T>(Int32)

Boş bir sınıfının yeni bir örneğini başlatır List<T> ve belirtilen ilk kapasiteye sahiptir.Initializes a new instance of the List<T> class that is empty and has the specified initial capacity.

Özellikler

Capacity

İç veri yapısının yeniden boyutlandırmadan tutabileceğiniz toplam öğe sayısını alır veya ayarlar.Gets or sets the total number of elements the internal data structure can hold without resizing.

Count

List<T> içindeki öğe sayısını alır.Gets the number of elements contained in the List<T>.

Item[Int32]

Belirtilen dizindeki öğeyi alır veya ayarlar.Gets or sets the element at the specified index.

Yöntemler

Add(T)

Sonuna bir nesnesi ekler List<T> .Adds an object to the end of the List<T>.

AddRange(IEnumerable<T>)

Belirtilen koleksiyonun öğelerini öğesinin sonuna ekler List<T> .Adds the elements of the specified collection to the end of the List<T>.

AsReadOnly()

ReadOnlyCollection<T>Geçerli koleksiyon için salt okunurdur bir sarmalayıcı döndürür.Returns a read-only ReadOnlyCollection<T> wrapper for the current collection.

BinarySearch(Int32, Int32, T, IComparer<T>)

List<T>Belirtilen karşılaştırıcıyı kullanarak bir öğe için sıralanmış bir öğe aralığını arar ve öğenin sıfır tabanlı dizinini döndürür.Searches a range of elements in the sorted List<T> for an element using the specified comparer and returns the zero-based index of the element.

BinarySearch(T)

List<T>Varsayılan karşılaştırıcıyı kullanarak bir öğenin tüm sıralanmasını arar ve öğenin sıfır tabanlı dizinini döndürür.Searches the entire sorted List<T> for an element using the default comparer and returns the zero-based index of the element.

BinarySearch(T, IComparer<T>)

List<T>Belirtilen karşılaştırıcıyı kullanarak bir öğenin tüm sıralanmasını arar ve öğenin sıfır tabanlı dizinini döndürür.Searches the entire sorted List<T> for an element using the specified comparer and returns the zero-based index of the element.

Clear()

Tüm öğeleri List<T> koleksiyonundan kaldırır.Removes all elements from the List<T>.

Contains(T)

Bir öğenin içinde olup olmadığını belirler List<T> .Determines whether an element is in the List<T>.

ConvertAll<TOutput>(Converter<T,TOutput>)

Geçerli içindeki öğeleri List<T> başka bir türe dönüştürür ve dönüştürülmüş öğeleri içeren bir liste döndürür.Converts the elements in the current List<T> to another type, and returns a list containing the converted elements.

CopyTo(Int32, T[], Int32, Int32)

İçindeki bir öğe aralığını, List<T> hedef dizinin belirtilen dizininden başlayarak, ile uyumlu bir boyutlu diziye kopyalar.Copies a range of elements from the List<T> to a compatible one-dimensional array, starting at the specified index of the target array.

CopyTo(T[])

List<T>Hedef dizinin başından başlayarak, tamamen uyumlu bir tek boyutlu diziye kopyalar.Copies the entire List<T> to a compatible one-dimensional array, starting at the beginning of the target array.

CopyTo(T[], Int32)

List<T>Hedef dizinin belirtilen dizininden başlayarak, tümünü uyumlu tek boyutlu bir diziye kopyalar.Copies the entire List<T> to a compatible one-dimensional array, starting at the specified index of the target array.

Equals(Object)

Belirtilen nesnenin geçerli nesneye eşit olup olmadığını belirler.Determines whether the specified object is equal to the current object.

(Devralındığı yer: Object)
Exists(Predicate<T>)

List<T>Öğesinin belirtilen koşul tarafından tanımlanan koşullara uyan öğeler içerip içermediğini belirler.Determines whether the List<T> contains elements that match the conditions defined by the specified predicate.

Find(Predicate<T>)

Belirtilen koşul tarafından tanımlanan koşullarla eşleşen bir öğe arar ve tüm içindeki ilk oluşumu döndürür List<T> .Searches for an element that matches the conditions defined by the specified predicate, and returns the first occurrence within the entire List<T>.

FindAll(Predicate<T>)

Belirtilen koşul tarafından tanımlanan koşullara uyan tüm öğeleri alır.Retrieves all the elements that match the conditions defined by the specified predicate.

FindIndex(Int32, Int32, Predicate<T>)

Belirtilen koşula göre tanımlanan koşullarla eşleşen bir öğe arar ve belirtilen List<T> dizinde başlayan ve belirtilen sayıda öğe içeren içindeki öğe aralığı içindeki ilk oluşumun sıfır tabanlı dizinini döndürür.Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the range of elements in the List<T> that starts at the specified index and contains the specified number of elements.

FindIndex(Int32, Predicate<T>)

Belirtilen koşul tarafından tanımlanan koşullarla eşleşen bir öğe arar ve List<T> belirtilen dizinden son öğeye genişleyen içindeki öğe aralığı içindeki ilk oluşumun sıfır tabanlı dizinini döndürür.Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the range of elements in the List<T> that extends from the specified index to the last element.

FindIndex(Predicate<T>)

Belirtilen koşul tarafından tanımlanan koşullarla eşleşen bir öğe arar ve tüm içindeki ilk oluşumun sıfır tabanlı dizinini döndürür List<T> .Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the entire List<T>.

FindLast(Predicate<T>)

Belirtilen koşul tarafından tanımlanan koşullarla eşleşen bir öğe arar ve tüm içindeki son oluşumu döndürür List<T> .Searches for an element that matches the conditions defined by the specified predicate, and returns the last occurrence within the entire List<T>.

FindLastIndex(Int32, Int32, Predicate<T>)

Belirtilen koşul tarafından tanımlanan koşullarla eşleşen bir öğe arar ve belirtilen List<T> dizinde belirtilen sayıda öğeyi içeren ve içindeki öğe aralığı içindeki son oluşumun sıfır tabanlı dizinini döndürür.Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the range of elements in the List<T> that contains the specified number of elements and ends at the specified index.

FindLastIndex(Int32, Predicate<T>)

Belirtilen koşul tarafından tanımlanan koşullarla eşleşen bir öğe arar ve List<T> ilk öğeden belirtilen dizine genişleyen içindeki öğe aralığı içinde son oluşumun sıfır tabanlı dizinini döndürür.Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the range of elements in the List<T> that extends from the first element to the specified index.

FindLastIndex(Predicate<T>)

Belirtilen koşul tarafından tanımlanan koşullarla eşleşen bir öğe arar ve tüm içindeki son oluşumun sıfır tabanlı dizinini döndürür List<T> .Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the entire List<T>.

ForEach(Action<T>)

Öğesinin her öğesinde belirtilen eylemi gerçekleştirir List<T> .Performs the specified action on each element of the List<T>.

GetEnumerator()

İle yinelenen bir Numaralandırıcı döndürür List<T> .Returns an enumerator that iterates through the List<T>.

GetHashCode()

Varsayılan karma işlevi olarak işlev görür.Serves as the default hash function.

(Devralındığı yer: Object)
GetRange(Int32, Int32)

Kaynaktaki bir dizi öğenin basit bir kopyasını oluşturur List<T> .Creates a shallow copy of a range of elements in the source List<T>.

GetType()

TypeGeçerli örneği alır.Gets the Type of the current instance.

(Devralındığı yer: Object)
IndexOf(T)

Belirtilen nesneyi arar ve tüm içindeki ilk oluşumun sıfır tabanlı dizinini döndürür List<T> .Searches for the specified object and returns the zero-based index of the first occurrence within the entire List<T>.

IndexOf(T, Int32)

Belirtilen nesneyi arar ve List<T> belirtilen dizinden son öğeye genişleyen içindeki öğe aralığı içindeki ilk oluşumun sıfır tabanlı dizinini döndürür.Searches for the specified object and returns the zero-based index of the first occurrence within the range of elements in the List<T> that extends from the specified index to the last element.

IndexOf(T, Int32, Int32)

Belirtilen nesneyi arar ve belirtilen List<T> dizinde başlayan ve belirtilen sayıda öğeyi içeren içindeki öğe aralığı içindeki ilk oluşumun sıfır tabanlı dizinini döndürür.Searches for the specified object and returns the zero-based index of the first occurrence within the range of elements in the List<T> that starts at the specified index and contains the specified number of elements.

Insert(Int32, T)

Belirtilen dizindeki öğesine bir öğesi ekler List<T> .Inserts an element into the List<T> at the specified index.

InsertRange(Int32, IEnumerable<T>)

Bir koleksiyonun öğelerini List<T> belirtilen dizine ekler.Inserts the elements of a collection into the List<T> at the specified index.

LastIndexOf(T)

Belirtilen nesneyi arar ve tüm içindeki son oluşumun sıfır tabanlı dizinini döndürür List<T> .Searches for the specified object and returns the zero-based index of the last occurrence within the entire List<T>.

LastIndexOf(T, Int32)

Belirtilen nesneyi arar ve List<T> ilk öğeden belirtilen dizine genişleten öğesi içindeki öğe aralığında son oluşumun sıfır tabanlı dizinini döndürür.Searches for the specified object and returns the zero-based index of the last occurrence within the range of elements in the List<T> that extends from the first element to the specified index.

LastIndexOf(T, Int32, Int32)

Belirtilen nesneyi arar ve belirtilen List<T> dizinde belirtilen sayıda öğeyi içeren ve içindeki öğe aralığı içindeki son oluşumun sıfır tabanlı dizinini döndürür.Searches for the specified object and returns the zero-based index of the last occurrence within the range of elements in the List<T> that contains the specified number of elements and ends at the specified index.

MemberwiseClone()

Geçerli bir basit kopyasını oluşturur Object .Creates a shallow copy of the current Object.

(Devralındığı yer: Object)
Remove(T)

İçindeki belirli bir nesnenin ilk oluşumunu kaldırır List<T> .Removes the first occurrence of a specific object from the List<T>.

RemoveAll(Predicate<T>)

Belirtilen koşul tarafından tanımlanan koşullara uyan tüm öğeleri kaldırır.Removes all the elements that match the conditions defined by the specified predicate.

RemoveAt(Int32)

Öğesinin belirtilen dizinindeki öğeyi kaldırır List<T> .Removes the element at the specified index of the List<T>.

RemoveRange(Int32, Int32)

Öğesinden bir dizi öğeyi kaldırır List<T> .Removes a range of elements from the List<T>.

Reverse()

Öğelerin sırasını tersine çevirir List<T> .Reverses the order of the elements in the entire List<T>.

Reverse(Int32, Int32)

Öğelerin belirtilen aralıktaki sırasını tersine çevirir.Reverses the order of the elements in the specified range.

Sort()

Tüm öğeleri List<T> varsayılan karşılaştırıcıyı kullanarak sıralar.Sorts the elements in the entire List<T> using the default comparer.

Sort(Comparison<T>)

Tüm öğeleri List<T> belirtilen kullanarak sıralar Comparison<T> .Sorts the elements in the entire List<T> using the specified Comparison<T>.

Sort(IComparer<T>)

Tüm öğeleri List<T> belirtilen karşılaştırıcıyı kullanarak sıralar.Sorts the elements in the entire List<T> using the specified comparer.

Sort(Int32, Int32, IComparer<T>)

Belirtilen karşılaştırıcıyı kullanarak öğeleri bir öğe aralığında sıralar List<T> .Sorts the elements in a range of elements in List<T> using the specified comparer.

ToArray()

Öğesinin öğelerini List<T> Yeni bir diziye kopyalar.Copies the elements of the List<T> to a new array.

ToString()

Geçerli nesneyi temsil eden dizeyi döndürür.Returns a string that represents the current object.

(Devralındığı yer: Object)
TrimExcess()

List<T>Bu sayı bir eşik değerinden küçükse, kapasitesini içindeki gerçek öğe sayısı olarak ayarlar.Sets the capacity to the actual number of elements in the List<T>, if that number is less than a threshold value.

TrueForAll(Predicate<T>)

İçindeki her öğenin List<T> belirtilen koşul tarafından tanımlanan koşullara uyup uymadığını belirler.Determines whether every element in the List<T> matches the conditions defined by the specified predicate.

Belirtik Arabirim Kullanımları

ICollection.CopyTo(Array, Int32)

Öğesinin öğelerini ICollection Array belirli bir dizinden başlayarak öğesine kopyalar Array .Copies the elements of the ICollection to an Array, starting at a particular Array index.

ICollection.IsSynchronized

Erişiminin ICollection eşitlenip eşitlenmediğini (iş parçacığı güvenli) gösteren bir değer alır.Gets a value indicating whether access to the ICollection is synchronized (thread safe).

ICollection.SyncRoot

Erişimini eşitlemede kullanılabilecek bir nesne alır ICollection .Gets an object that can be used to synchronize access to the ICollection.

ICollection<T>.IsReadOnly

ICollection<T> öğesinin salt okunur olup olmadığını belirten bir değer alır.Gets a value indicating whether the ICollection<T> is read-only.

IEnumerable.GetEnumerator()

Bir toplulukta tekrarlanan bir numaralandırıcı döndürür.Returns an enumerator that iterates through a collection.

IEnumerable<T>.GetEnumerator()

Bir toplulukta tekrarlanan bir numaralandırıcı döndürür.Returns an enumerator that iterates through a collection.

IList.Add(Object)

Öğesine bir öğe ekler IList .Adds an item to the IList.

IList.Contains(Object)

' In IList belirli bir değer içerip içermediğini belirler.Determines whether the IList contains a specific value.

IList.IndexOf(Object)

İçindeki belirli bir öğenin dizinini belirler IList .Determines the index of a specific item in the IList.

IList.Insert(Int32, Object)

Belirtilen dizindeki öğesine bir öğe ekler IList .Inserts an item to the IList at the specified index.

IList.IsFixedSize

Değerinin sabit boyutta olup olmadığını gösteren bir değer alır IList .Gets a value indicating whether the IList has a fixed size.

IList.IsReadOnly

IList öğesinin salt okunur olup olmadığını belirten bir değer alır.Gets a value indicating whether the IList is read-only.

IList.Item[Int32]

Belirtilen dizindeki öğeyi alır veya ayarlar.Gets or sets the element at the specified index.

IList.Remove(Object)

İçindeki belirli bir nesnenin ilk oluşumunu kaldırır IList .Removes the first occurrence of a specific object from the IList.

Uzantı Metotları

ToImmutableArray<TSource>(IEnumerable<TSource>)

Belirtilen koleksiyondan sabit bir dizi oluşturur.Creates an immutable array from the specified collection.

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

Kaynak anahtarlarına bir dönüştürme işlevi uygulayarak, varolan bir öğe koleksiyonundan sabit bir sözlük oluşturur.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>)

Bir dizinin bazı dönüştürmesinden temel olarak sabit bir sözlük oluşturur.Constructs an immutable dictionary based on some transformation of a sequence.

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

Bir sırayı numaralandırır ve dönüştürür ve içeriklerinin sabit bir sözlüğünü üretir.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>)

Bir sırayı numaralandırır ve dönüştürür ve belirtilen anahtar karşılaştırıcıyı kullanarak içeriklerinin sabit bir sözlüğünü oluşturur.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>)

Bir sırayı numaralandırır ve dönüştürür ve belirtilen anahtar ve değer Karşılaştırıcılar kullanılarak içeriklerinin sabit bir sözlüğünü üretir.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>)

Bir diziyi numaralandırır ve içeriklerinin sabit bir karma kümesini oluşturur.Enumerates a sequence and produces an immutable hash set of its contents.

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

Bir diziyi numaralandırır, içeriklerinin sabit bir karma kümesini üretir ve küme türü için belirtilen eşitlik karşılaştırıcıyı kullanır.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>)

Bir diziyi numaralandırır ve içeriklerinin sabit bir listesini oluşturur.Enumerates a sequence and produces an immutable list of its contents.

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

Bir sırayı numaralandırır ve dönüştürür ve içeriklerinin sabit sıralanmış bir sözlüğünü üretir.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>)

Bir sırayı numaralandırır ve dönüştürür ve belirtilen anahtar karşılaştırıcıyı kullanarak içeriklerinin sabit sıralanmış bir sözlüğünü üretir.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>)

Bir sırayı numaralandırır ve dönüştürür ve belirtilen anahtar ve değer Karşılaştırıcılar kullanılarak içeriklerinin sabit sıralanmış bir sözlüğünü üretir.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>)

Bir diziyi numaralandırır ve içeriklerinin sabit sıralanmış bir kümesini oluşturur.Enumerates a sequence and produces an immutable sorted set of its contents.

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

Bir diziyi numaralandırır, içeriklerinin sabit sıralanmış bir kümesini üretir ve belirtilen karşılaştırıcıyı kullanır.Enumerates a sequence, produces an immutable sorted set of its contents, and uses the specified comparer.

CopyToDataTable<T>(IEnumerable<T>)

DataTable DataRow Genel parametrenin bulunduğu bir giriş nesnesi verildiğinde, nesnelerin kopyalarını içeren bir döndürür IEnumerable<T> 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)

DataRowNesneleri DataTable , IEnumerable<T> genel parametresinin bulunduğu bir giriş nesnesi verildiğinde, belirtilen öğesine kopyalar T 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)

DataRowNesneleri DataTable , IEnumerable<T> genel parametresinin bulunduğu bir giriş nesnesi verildiğinde, belirtilen öğesine kopyalar T 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>)

Bir sıra üzerinde bir biriktiricidir işlevi uygular.Applies an accumulator function over a sequence.

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

Bir sıra üzerinde bir biriktiricidir işlevi uygular.Applies an accumulator function over a sequence. Belirtilen çekirdek değeri, ilk biriktiricidir değeri olarak kullanılır.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>)

Bir sıra üzerinde bir biriktiricidir işlevi uygular.Applies an accumulator function over a sequence. Belirtilen çekirdek değeri, ilk biriktiricidir değeri olarak kullanılır ve sonuç değerini seçmek için belirtilen işlev kullanılır.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>)

Bir dizinin tüm öğelerinin bir koşulu karşılayıp karşılamadığını belirler.Determines whether all elements of a sequence satisfy a condition.

Any<TSource>(IEnumerable<TSource>)

Bir sıranın herhangi bir öğe içerip içermediğini belirler.Determines whether a sequence contains any elements.

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

Bir dizinin herhangi bir öğesinin bir koşulu karşılayıp karşılamadığını belirler.Determines whether any element of a sequence satisfies a condition.

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

Dizinin sonuna bir değer ekler.Appends a value to the end of the sequence.

AsEnumerable<TSource>(IEnumerable<TSource>)

Olarak yazılan girişi döndürür IEnumerable<T> .Returns the input typed as IEnumerable<T>.

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

DecimalGiriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen bir değer dizisinin ortalamasını hesaplar.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>)

DoubleGiriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen bir değer dizisinin ortalamasını hesaplar.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>)

Int32Giriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen bir değer dizisinin ortalamasını hesaplar.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>)

Int64Giriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen bir değer dizisinin ortalamasını hesaplar.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>>)

DecimalGiriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen bir null yapılabilir değerler dizisinin ortalamasını hesaplar.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>>)

DoubleGiriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen bir null yapılabilir değerler dizisinin ortalamasını hesaplar.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>>)

Int32Giriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen bir null yapılabilir değerler dizisinin ortalamasını hesaplar.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>>)

Int64Giriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen bir null yapılabilir değerler dizisinin ortalamasını hesaplar.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>>)

SingleGiriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen bir null yapılabilir değerler dizisinin ortalamasını hesaplar.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>)

SingleGiriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen bir değer dizisinin ortalamasını hesaplar.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)

Öğesinin öğelerini IEnumerable belirtilen türe yayınlar.Casts the elements of an IEnumerable to the specified type.

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

İki diziyi art arda ekler.Concatenates two sequences.

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

Varsayılan eşitlik karşılaştırıcıyı kullanarak bir sıranın belirtilen öğeyi içerip içermediğini belirler.Determines whether a sequence contains a specified element by using the default equality comparer.

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

Belirtilen öğeyi kullanarak bir sıranın belirtilen öğeyi içerip içermediğini belirler IEqualityComparer<T> .Determines whether a sequence contains a specified element by using a specified IEqualityComparer<T>.

Count<TSource>(IEnumerable<TSource>)

Dizideki öğe sayısını döndürür.Returns the number of elements in a sequence.

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

Belirtilen dizideki kaç öğenin bir koşulu karşılayıp karşılamadığını temsil eden bir sayı döndürür.Returns a number that represents how many elements in the specified sequence satisfy a condition.

DefaultIfEmpty<TSource>(IEnumerable<TSource>)

Dizi boşsa, tek bir koleksiyonda belirtilen sıranın veya tür parametresinin varsayılan değerinin varsayılan değerini döndürür.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)

Dizi boşsa, tek bir koleksiyonda belirtilen sıranın veya belirtilen değerin öğelerini döndürür.Returns the elements of the specified sequence or the specified value in a singleton collection if the sequence is empty.

Distinct<TSource>(IEnumerable<TSource>)

Değerleri karşılaştırmak için varsayılan eşitlik karşılaştırıcıyı kullanarak bir dizideki ayrı öğeleri döndürür.Returns distinct elements from a sequence by using the default equality comparer to compare values.

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

Değerleri karşılaştırmak için belirtilen ' i kullanarak bir dizideki ayrı öğeleri döndürür IEqualityComparer<T> .Returns distinct elements from a sequence by using a specified IEqualityComparer<T> to compare values.

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

Bir dizideki belirtilen dizindeki öğeyi döndürür.Returns the element at a specified index in a sequence.

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

Dizin aralık dışında bir dizide belirtilen dizindeki öğeyi veya varsayılan değeri döndürür.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>)

Değerleri karşılaştırmak için varsayılan eşitlik karşılaştırıcıyı kullanarak iki sıranın ayarlama farkını üretir.Produces the set difference of two sequences by using the default equality comparer to compare values.

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

Değerleri karşılaştırmak için belirtilen ' i kullanarak iki sıranın ayarlama farkını üretir IEqualityComparer<T> .Produces the set difference of two sequences by using the specified IEqualityComparer<T> to compare values.

First<TSource>(IEnumerable<TSource>)

Sıradaki ilk öğeyi döndürür.Returns the first element of a sequence.

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

Belirli bir koşulu karşılayan bir dizideki ilk öğeyi döndürür.Returns the first element in a sequence that satisfies a specified condition.

FirstOrDefault<TSource>(IEnumerable<TSource>)

Bir dizinin ilk öğesini veya dizi hiçbir öğe içermiyorsa varsayılan değeri döndürür.Returns the first element of a sequence, or a default value if the sequence contains no elements.

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

Bu tür bir öğe bulunamazsa, bir koşulu karşılayan dizinin ilk öğesini veya varsayılan değeri döndürür.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>)

Bir dizinin öğelerini belirtilen bir anahtar Seçicisi işlevine göre gruplandırır.Groups the elements of a sequence according to a specified key selector function.

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

Bir dizinin öğelerini belirtilen bir anahtar Seçicisi işlevine göre gruplandırır ve belirtilen karşılaştırıcıyı kullanarak anahtarları karşılaştırır.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>)

Bir dizinin öğelerini belirtilen bir anahtar Seçici işlevine göre gruplandırır ve belirtilen bir işlevi kullanarak her grup için öğeleri projeler halinde gruplandırır.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>)

Bir sıranın öğelerini bir anahtar Seçici işlevine göre gruplandırır.Groups the elements of a sequence according to a key selector function. Anahtarlar bir karşılaştırıcı kullanılarak karşılaştırılır ve her grubun öğeleri belirtilen bir işlev kullanılarak yansıtılmakta.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>)

Bir dizinin öğelerini belirtilen bir anahtar Seçicisi işlevine göre gruplandırır ve her bir gruptan ve onun anahtarından bir sonuç değeri oluşturur.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>)

Bir dizinin öğelerini belirtilen bir anahtar Seçicisi işlevine göre gruplandırır ve her bir gruptan ve onun anahtarından bir sonuç değeri oluşturur.Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key. Anahtarlar, belirtilen karşılaştırıcı kullanılarak karşılaştırılır.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>)

Bir dizinin öğelerini belirtilen bir anahtar Seçicisi işlevine göre gruplandırır ve her bir gruptan ve onun anahtarından bir sonuç değeri oluşturur.Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key. Her grubun öğeleri belirtilen bir işlev kullanılarak yansıtıllardır.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>)

Bir dizinin öğelerini belirtilen bir anahtar Seçicisi işlevine göre gruplandırır ve her bir gruptan ve onun anahtarından bir sonuç değeri oluşturur.Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key. Anahtar değerleri belirtilen karşılaştırıcı kullanılarak karşılaştırılır ve her grubun öğeleri belirtilen bir işlev kullanılarak yansıtılmakta.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>)

Anahtarların eşitliğine göre iki sıranın öğelerini karşılıklı olarak ilişkilendirir ve sonuçları gruplandırır.Correlates the elements of two sequences based on equality of keys and groups the results. Anahtarları karşılaştırmak için varsayılan eşitlik karşılaştırıcısı kullanılır.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>)

İki sıranın öğelerini anahtar eşitliğine göre ilişkilendirir ve sonuçları gruplandırır.Correlates the elements of two sequences based on key equality and groups the results. IEqualityComparer<T>Anahtarları karşılaştırmak için belirtilen bir kullanılır.A specified IEqualityComparer<T> is used to compare keys.

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

Değerleri karşılaştırmak için varsayılan eşitlik karşılaştırıcıyı kullanarak iki sıranın küme kesişimini üretir.Produces the set intersection of two sequences by using the default equality comparer to compare values.

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

Değerleri karşılaştırmak için belirtilen ' i kullanarak iki sıranın küme kesişimini üretir IEqualityComparer<T> .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>)

İki sıranın öğelerini eşleşen anahtarlara göre karşılıklı olarak ilişkilendirir.Correlates the elements of two sequences based on matching keys. Anahtarları karşılaştırmak için varsayılan eşitlik karşılaştırıcısı kullanılır.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>)

İki sıranın öğelerini eşleşen anahtarlara göre karşılıklı olarak ilişkilendirir.Correlates the elements of two sequences based on matching keys. IEqualityComparer<T>Anahtarları karşılaştırmak için belirtilen bir kullanılır.A specified IEqualityComparer<T> is used to compare keys.

Last<TSource>(IEnumerable<TSource>)

Sıradaki son öğeyi döndürür.Returns the last element of a sequence.

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

Belirtilen bir koşulu karşılayan bir dizinin son öğesini döndürür.Returns the last element of a sequence that satisfies a specified condition.

LastOrDefault<TSource>(IEnumerable<TSource>)

Bir sıranın son öğesini veya dizi hiçbir öğe içermiyorsa varsayılan değeri döndürür.Returns the last element of a sequence, or a default value if the sequence contains no elements.

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

Böyle bir öğe bulunmazsa bir koşulu karşılayan bir sıranın son öğesini veya varsayılan değeri döndürür.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>)

Int64Bir dizideki toplam öğe sayısını temsil eden bir döndürür.Returns an Int64 that represents the total number of elements in a sequence.

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

Bir Int64 dizideki kaç öğenin bir koşulu karşılayıp karşılamadığını temsil eden bir döndürür.Returns an Int64 that represents how many elements in a sequence satisfy a condition.

Max<TSource>(IEnumerable<TSource>)

Genel dizideki en büyük değeri döndürür.Returns the maximum value in a generic sequence.

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

Bir dizideki her öğe için bir Transform işlevini çağırır ve en büyük değeri döndürür Decimal .Invokes a transform function on each element of a sequence and returns the maximum Decimal value.

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

Bir dizideki her öğe için bir Transform işlevini çağırır ve en büyük değeri döndürür Double .Invokes a transform function on each element of a sequence and returns the maximum Double value.

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

Bir dizideki her öğe için bir Transform işlevini çağırır ve en büyük değeri döndürür Int32 .Invokes a transform function on each element of a sequence and returns the maximum Int32 value.

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

Bir dizideki her öğe için bir Transform işlevini çağırır ve en büyük değeri döndürür Int64 .Invokes a transform function on each element of a sequence and returns the maximum Int64 value.

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

Bir dizideki her öğe için bir Transform işlevini çağırır ve en fazla boş değer atanabilir Decimal değeri döndürür.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>>)

Bir dizideki her öğe için bir Transform işlevini çağırır ve en fazla boş değer atanabilir Double değeri döndürür.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>>)

Bir dizideki her öğe için bir Transform işlevini çağırır ve en fazla boş değer atanabilir Int32 değeri döndürür.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>>)

Bir dizideki her öğe için bir Transform işlevini çağırır ve en fazla boş değer atanabilir Int64 değeri döndürür.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>>)

Bir dizideki her öğe için bir Transform işlevini çağırır ve en fazla boş değer atanabilir Single değeri döndürür.Invokes a transform function on each element of a sequence and returns the maximum nullable Single value.

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

Bir dizideki her öğe için bir Transform işlevini çağırır ve en büyük değeri döndürür Single .Invokes a transform function on each element of a sequence and returns the maximum Single value.

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

Genel bir dizinin her öğesinde bir Transform işlevini çağırır ve elde edilen en büyük değeri döndürür.Invokes a transform function on each element of a generic sequence and returns the maximum resulting value.

Min<TSource>(IEnumerable<TSource>)

Genel bir dizideki en küçük değeri döndürür.Returns the minimum value in a generic sequence.

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

Bir dizideki her öğe için bir Transform işlevini çağırır ve en küçük değeri döndürür Decimal .Invokes a transform function on each element of a sequence and returns the minimum Decimal value.

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

Bir dizideki her öğe için bir Transform işlevini çağırır ve en küçük değeri döndürür Double .Invokes a transform function on each element of a sequence and returns the minimum Double value.

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

Bir dizideki her öğe için bir Transform işlevini çağırır ve en küçük değeri döndürür Int32 .Invokes a transform function on each element of a sequence and returns the minimum Int32 value.

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

Bir dizideki her öğe için bir Transform işlevini çağırır ve en küçük değeri döndürür Int64 .Invokes a transform function on each element of a sequence and returns the minimum Int64 value.

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

Bir dizideki her öğe için bir Transform işlevini çağırır ve en az boş değer atanabilir Decimal değeri döndürür.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>>)

Bir dizideki her öğe için bir Transform işlevini çağırır ve en az boş değer atanabilir Double değeri döndürür.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>>)

Bir dizideki her öğe için bir Transform işlevini çağırır ve en az boş değer atanabilir Int32 değeri döndürür.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>>)

Bir dizideki her öğe için bir Transform işlevini çağırır ve en az boş değer atanabilir Int64 değeri döndürür.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>>)

Bir dizideki her öğe için bir Transform işlevini çağırır ve en az boş değer atanabilir Single değeri döndürür.Invokes a transform function on each element of a sequence and returns the minimum nullable Single value.

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

Bir dizideki her öğe için bir Transform işlevini çağırır ve en küçük değeri döndürür Single .Invokes a transform function on each element of a sequence and returns the minimum Single value.

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

Genel bir dizinin her öğesinde bir Transform işlevini çağırır ve elde edilen en küçük değeri döndürür.Invokes a transform function on each element of a generic sequence and returns the minimum resulting value.

OfType<TResult>(IEnumerable)

Öğesinin öğelerini IEnumerable belirtilen bir türe göre filtreler.Filters the elements of an IEnumerable based on a specified type.

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

Bir dizinin öğelerini bir anahtara göre artan düzende sıralar.Sorts the elements of a sequence in ascending order according to a key.

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

Belirtilen karşılaştırıcıyı kullanarak bir sıranın öğelerini artan düzende sıralar.Sorts the elements of a sequence in ascending order by using a specified comparer.

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

Bir dizinin öğelerini bir anahtara göre azalan düzende sıralar.Sorts the elements of a sequence in descending order according to a key.

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

Belirtilen karşılaştırıcıyı kullanarak bir dizinin öğelerini azalan sırada sıralar.Sorts the elements of a sequence in descending order by using a specified comparer.

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

Dizinin başlangıcına bir değer ekler.Adds a value to the beginning of the sequence.

Reverse<TSource>(IEnumerable<TSource>)

Bir dizideki öğelerin sırasını tersine çevirir.Inverts the order of the elements in a sequence.

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

Bir dizinin her öğesini yeni bir biçimde projeler.Projects each element of a sequence into a new form.

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

Öğenin dizinini ekleyerek bir sıranın her öğesini yeni bir biçimde projeler.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>>)

Bir sıranın her bir öğesini bir öğesine IEnumerable<T> ve ortaya çıkan dizileri tek bir sırayla düzleştirir.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>>)

Bir sıranın her bir öğesini bir öğesine IEnumerable<T> ve ortaya çıkan dizileri tek bir sırayla düzleştirir.Projects each element of a sequence to an IEnumerable<T>, and flattens the resulting sequences into one sequence. Her kaynak öğenin dizini, bu öğenin öngörülen formunda kullanılır.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>)

Bir dizinin her bir öğesi için olan projeler IEnumerable<T> , ortaya çıkan dizileri tek bir sırayla düzleştirir ve içindeki her öğe için bir sonuç Seçicisi işlevini çağırır.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>)

Bir dizinin her bir öğesi için olan projeler IEnumerable<T> , ortaya çıkan dizileri tek bir sırayla düzleştirir ve içindeki her öğe için bir sonuç Seçicisi işlevini çağırır.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. Her kaynak öğenin dizini, bu öğenin ara tasarlanan formunda kullanılır.The index of each source element is used in the intermediate projected form of that element.

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

İki sıranın, türleri için varsayılan eşitlik karşılaştırıcıyı kullanarak öğeleri karşılaştırarak eşit olup olmadığını belirler.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>)

İki sıranın, öğelerini belirtilen bir kullanarak karşılaştırarak eşit olup olmadığını belirler IEqualityComparer<T> .Determines whether two sequences are equal by comparing their elements by using a specified IEqualityComparer<T>.

Single<TSource>(IEnumerable<TSource>)

Sıranın tek bir öğesini döndürür ve dizide tam olarak bir öğe yoksa bir özel durum oluşturur.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>)

Belirtilen koşulu karşılayan bir dizinin tek öğesini döndürür ve birden fazla öğe varsa bir özel durum oluşturur.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>)

Bir dizinin tek bir öğesini veya dizi boşsa varsayılan değeri döndürür; dizide birden fazla öğe varsa, bu yöntem bir özel durum oluşturur.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>)

Belirtilen bir koşulu veya böyle bir öğe yoksa varsayılan değeri karşılayan bir dizinin tek öğesini döndürür; Bu yöntem, koşulu karşılıyorsa, birden fazla öğe bir özel durum oluşturur.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)

Bir dizide belirtilen sayıda öğeyi atlar ve ardından kalan öğeleri döndürür.Bypasses a specified number of elements in a sequence and then returns the remaining elements.

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

sourceKaynak koleksiyonun son öğeleriyle öğesinden öğeleri içeren yeni bir sıralanabilir koleksiyon döndürür count .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>)

Belirtilen koşul doğru olduğu sürece dizideki öğeleri atlar ve kalan öğeleri döndürür.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>)

Belirtilen koşul doğru olduğu sürece dizideki öğeleri atlar ve kalan öğeleri döndürür.Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements. Öğenin dizini koşul işlevinin mantığında kullanılır.The element's index is used in the logic of the predicate function.

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

DecimalGiriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen değer dizisinin toplamını hesaplar.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>)

DoubleGiriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen değer dizisinin toplamını hesaplar.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>)

Int32Giriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen değer dizisinin toplamını hesaplar.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>)

Int64Giriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen değer dizisinin toplamını hesaplar.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>>)

DecimalGiriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen null yapılabilir değerler dizisinin toplamını hesaplar.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>>)

DoubleGiriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen null yapılabilir değerler dizisinin toplamını hesaplar.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>>)

Int32Giriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen null yapılabilir değerler dizisinin toplamını hesaplar.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>>)

Int64Giriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen null yapılabilir değerler dizisinin toplamını hesaplar.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>>)

SingleGiriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen null yapılabilir değerler dizisinin toplamını hesaplar.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>)

SingleGiriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen değer dizisinin toplamını hesaplar.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)

Bir sıranın başından itibaren belirtilen sayıda bitişik öğeyi döndürür.Returns a specified number of contiguous elements from the start of a sequence.

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

Öğesinden son öğeleri içeren yeni bir sıralanabilir koleksiyon döndürür count source .Returns a new enumerable collection that contains the last count elements from source.

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

Belirtilen koşul doğru olduğu sürece bir dizideki öğeleri döndürür.Returns elements from a sequence as long as a specified condition is true.

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

Belirtilen koşul doğru olduğu sürece bir dizideki öğeleri döndürür.Returns elements from a sequence as long as a specified condition is true. Öğenin dizini koşul işlevinin mantığında kullanılır.The element's index is used in the logic of the predicate function.

ToArray<TSource>(IEnumerable<TSource>)

Bir öğesinden bir dizi oluşturur IEnumerable<T> .Creates an array from a IEnumerable<T>.

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

Dictionary<TKey,TValue> IEnumerable<T> Belirtilen anahtar Seçici işlevine göre bir öğesinden bir oluşturur.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>)

Dictionary<TKey,TValue> IEnumerable<T> Belirtilen anahtar Seçici işlevine ve anahtar karşılaştırıcısı 'na göre bir öğesinden bir oluşturur.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>)

Dictionary<TKey,TValue> IEnumerable<T> Belirtilen anahtar seçicisine ve öğe Seçici işlevlerine göre bir öğesinden bir oluşturur.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>)

Dictionary<TKey,TValue> IEnumerable<T> Belirtilen anahtar Seçici işlevine, karşılaştırıcının ve öğe Seçici işlevine göre bir öğesinden bir oluşturur.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>)

Kaynağından bir oluşturur HashSet<T> IEnumerable<T> .Creates a HashSet<T> from an IEnumerable<T>.

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

HashSet<T> IEnumerable<T> Anahtarları karşılaştırmak için kullanarak öğesinden bir oluşturur comparer .Creates a HashSet<T> from an IEnumerable<T> using the comparer to compare keys.

ToList<TSource>(IEnumerable<TSource>)

Kaynağından bir oluşturur List<T> IEnumerable<T> .Creates a List<T> from an IEnumerable<T>.

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

Lookup<TKey,TElement> IEnumerable<T> Belirtilen anahtar Seçici işlevine göre bir öğesinden bir oluşturur.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>)

Lookup<TKey,TElement> IEnumerable<T> Belirtilen anahtar Seçici işlevine ve anahtar karşılaştırıcısı 'na göre bir öğesinden bir oluşturur.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>)

Lookup<TKey,TElement> IEnumerable<T> Belirtilen anahtar seçicisine ve öğe Seçici işlevlerine göre bir öğesinden bir oluşturur.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>)

Bir Lookup<TKey,TElement> IEnumerable<T> karşılaştırıcı ve bir öğe Seçici işlevi olan belirtilen bir anahtar Seçici işlevine göre bir ile oluşturur.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>)

Varsayılan eşitlik karşılaştırıcıyı kullanarak iki sıranın set birleşimini üretir.Produces the set union of two sequences by using the default equality comparer.

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

Belirtilen bir kullanarak iki sıranın set birleşimini üretir IEqualityComparer<T> .Produces the set union of two sequences by using a specified IEqualityComparer<T>.

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

Bir koşula göre bir değer dizisini filtreler.Filters a sequence of values based on a predicate.

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

Bir koşula göre bir değer dizisini filtreler.Filters a sequence of values based on a predicate. Her öğenin dizini koşul işlevinin mantığındaki kullanılır.Each element's index is used in the logic of the predicate function.

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

Belirtilen iki dizideki öğeleri içeren bir tanımlama grubu sırası üretir.Produces a sequence of tuples with elements from the two specified sequences.

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

Belirtilen bir işlevi, iki sıranın karşılık gelen öğelerine uygular ve sonuçların bir dizisini üretir.Applies a specified function to the corresponding elements of two sequences, producing a sequence of the results.

AsParallel(IEnumerable)

Bir sorgunun paralelleştirilmesini mümkün hale getirme.Enables parallelization of a query.

AsParallel<TSource>(IEnumerable<TSource>)

Bir sorgunun paralelleştirilmesini mümkün hale getirme.Enables parallelization of a query.

AsQueryable(IEnumerable)

Bir IEnumerable öğesine dönüştürür IQueryable .Converts an IEnumerable to an IQueryable.

AsQueryable<TElement>(IEnumerable<TElement>)

Genel ' i IEnumerable<T> genel olarak dönüştürür IQueryable<T> .Converts a generic IEnumerable<T> to a generic IQueryable<T>.

Ancestors<T>(IEnumerable<T>)

Kaynak koleksiyondaki her düğümün üst öğelerini içeren öğelerin koleksiyonunu döndürür.Returns a collection of elements that contains the ancestors of every node in the source collection.

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

Kaynak koleksiyondaki her düğümün üst öğelerini içeren bir öğe filtrelenmiş koleksiyonunu döndürür.Returns a filtered collection of elements that contains the ancestors of every node in the source collection. Yalnızca eşleşen öğeler XName koleksiyona dahil edilir.Only elements that have a matching XName are included in the collection.

DescendantNodes<T>(IEnumerable<T>)

Kaynak koleksiyondaki her belge ve öğenin alt düğümlerinin bir koleksiyonunu döndürür.Returns a collection of the descendant nodes of every document and element in the source collection.

Descendants<T>(IEnumerable<T>)

Kaynak koleksiyondaki her öğe ve belge için alt öğeleri içeren öğelerin koleksiyonunu döndürür.Returns a collection of elements that contains the descendant elements of every element and document in the source collection.

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

Kaynak koleksiyondaki her öğe ve belge için alt öğeleri içeren öğelerin filtrelenmiş bir koleksiyonunu döndürür.Returns a filtered collection of elements that contains the descendant elements of every element and document in the source collection. Yalnızca eşleşen öğeler XName koleksiyona dahil edilir.Only elements that have a matching XName are included in the collection.

Elements<T>(IEnumerable<T>)

Kaynak koleksiyondaki her öğe ve belgenin alt öğelerinin bir koleksiyonunu döndürür.Returns a collection of the child elements of every element and document in the source collection.

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

Kaynak koleksiyondaki her öğe ve belge için alt öğelerin filtrelenmiş bir koleksiyonunu döndürür.Returns a filtered collection of the child elements of every element and document in the source collection. Yalnızca eşleşen öğeler XName koleksiyona dahil edilir.Only elements that have a matching XName are included in the collection.

InDocumentOrder<T>(IEnumerable<T>)

Belge düzeninde sıralanan, kaynak koleksiyondaki tüm düğümleri içeren düğümlerin bir koleksiyonunu döndürür.Returns a collection of nodes that contains all nodes in the source collection, sorted in document order.

Nodes<T>(IEnumerable<T>)

Kaynak koleksiyondaki her belge ve öğenin alt düğümlerinin bir koleksiyonunu döndürür.Returns a collection of the child nodes of every document and element in the source collection.

Remove<T>(IEnumerable<T>)

Kaynak koleksiyondaki her düğümü üst düğümünden kaldırır.Removes every node in the source collection from its parent node.

Şunlara uygulanır

İş Parçacığı Güvenliği

Ortak statik ( Shared Visual Basic) bu türün üyeleri iş parçacığı güvenlidir.Public static (Shared in Visual Basic) members of this type are thread safe. Örnek üyelerin iş parçacığı güvenli olmaları garanti edilmez.Any instance members are not guaranteed to be thread safe.

Bir üzerinde birden çok okuma işlemi gerçekleştirmek güvenlidir List<T> , ancak koleksiyon okunurken değiştirilirse sorunlar ortaya çıkabilir.It is safe to perform multiple read operations on a List<T>, but issues can occur if the collection is modified while it's being read. İş parçacığı güvenliğini sağlamak için, okuma veya yazma işlemi sırasında koleksiyonu kilitleyin.To ensure thread safety, lock the collection during a read or write operation. Bir koleksiyona, okuma ve yazma için birden çok iş parçacığı tarafından erişilebilmesini sağlamak için kendi eşitlemesini uygulamanız gerekir.To enable a collection to be accessed by multiple threads for reading and writing, you must implement your own synchronization. Yerleşik eşitlemeye sahip koleksiyonlar için, System.Collections.Concurrent ad alanındaki sınıflara bakın.For collections with built-in synchronization, see the classes in the System.Collections.Concurrent namespace. Bir kendiliğinden iş parçacığı açısından güvenli alternatif için, ImmutableList<T> sınıfına bakın.For an inherently thread-safe alternative, see the ImmutableList<T> class.

Ayrıca bkz.