LinkedList<T> Klasse
Definition
Wichtig
Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.
Stellt eine doubly verknüpfte Liste dar.
generic <typename T>
public ref class LinkedList : System::Collections::Generic::ICollection<T>, System::Collections::Generic::IEnumerable<T>, System::Collections::Generic::IReadOnlyCollection<T>, System::Collections::ICollection
generic <typename T>
public ref class LinkedList : System::Collections::Generic::ICollection<T>, System::Collections::Generic::IEnumerable<T>, System::Collections::Generic::IReadOnlyCollection<T>, System::Collections::ICollection, System::Runtime::Serialization::IDeserializationCallback, System::Runtime::Serialization::ISerializable
generic <typename T>
public ref class LinkedList : System::Collections::Generic::ICollection<T>, System::Collections::Generic::IEnumerable<T>, System::Collections::ICollection, System::Runtime::Serialization::IDeserializationCallback, System::Runtime::Serialization::ISerializable
generic <typename T>
public ref class LinkedList : System::Collections::Generic::ICollection<T>, System::Collections::Generic::IEnumerable<T>, System::Collections::ICollection
public class LinkedList<T> : System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IReadOnlyCollection<T>, System.Collections.ICollection
public class LinkedList<T> : System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IReadOnlyCollection<T>, System.Collections.ICollection, System.Runtime.Serialization.IDeserializationCallback, System.Runtime.Serialization.ISerializable
[System.Runtime.InteropServices.ComVisible(false)]
[System.Serializable]
public class LinkedList<T> : System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.ICollection, System.Runtime.Serialization.IDeserializationCallback, System.Runtime.Serialization.ISerializable
[System.Runtime.InteropServices.ComVisible(false)]
[System.Serializable]
public class LinkedList<T> : System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IReadOnlyCollection<T>, System.Collections.ICollection, System.Runtime.Serialization.IDeserializationCallback, System.Runtime.Serialization.ISerializable
public class LinkedList<T> : System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.ICollection
type LinkedList<'T> = class
interface ICollection<'T>
interface seq<'T>
interface IEnumerable
interface IReadOnlyCollection<'T>
interface ICollection
type LinkedList<'T> = class
interface ICollection<'T>
interface seq<'T>
interface IEnumerable
interface IReadOnlyCollection<'T>
interface ICollection
interface IDeserializationCallback
interface ISerializable
[<System.Runtime.InteropServices.ComVisible(false)>]
[<System.Serializable>]
type LinkedList<'T> = class
interface ICollection<'T>
interface seq<'T>
interface ICollection
interface IEnumerable
interface ISerializable
interface IDeserializationCallback
[<System.Runtime.InteropServices.ComVisible(false)>]
[<System.Serializable>]
type LinkedList<'T> = class
interface ICollection<'T>
interface seq<'T>
interface IEnumerable
interface ICollection
interface IReadOnlyCollection<'T>
interface ISerializable
interface IDeserializationCallback
type LinkedList<'T> = class
interface ICollection<'T>
interface seq<'T>
interface ICollection
interface IEnumerable
Public Class LinkedList(Of T)
Implements ICollection, ICollection(Of T), IEnumerable(Of T), IReadOnlyCollection(Of T)
Public Class LinkedList(Of T)
Implements ICollection, ICollection(Of T), IDeserializationCallback, IEnumerable(Of T), IReadOnlyCollection(Of T), ISerializable
Public Class LinkedList(Of T)
Implements ICollection, ICollection(Of T), IDeserializationCallback, IEnumerable(Of T), ISerializable
Public Class LinkedList(Of T)
Implements ICollection, ICollection(Of T), IEnumerable(Of T)
Typparameter
- T
Gibt den Elementtyp der verknüpften Liste an.
- Vererbung
-
LinkedList<T>
- Attribute
- Implementiert
Beispiele
Im folgenden Codebeispiel werden viele Features der LinkedList<T> Klasse veranschaulicht.
#using <System.dll>
using namespace System;
using namespace System::Text;
using namespace System::Collections::Generic;
public ref class Example
{
public:
static void Main()
{
// Create the link list.
array<String^>^ words =
{ "the", "fox", "jumped", "over", "the", "dog" };
LinkedList<String^>^ sentence = gcnew LinkedList<String^>(words);
Display(sentence, "The linked list values:");
Console::WriteLine("sentence.Contains(\"jumped\") = {0}",
sentence->Contains("jumped"));
// Add the word 'today' to the beginning of the linked list.
sentence->AddFirst("today");
Display(sentence, "Test 1: Add 'today' to beginning of the list:");
// Move the first node to be the last node.
LinkedListNode<String^>^ mark1 = sentence->First;
sentence->RemoveFirst();
sentence->AddLast(mark1);
Display(sentence, "Test 2: Move first node to be last node:");
// Change the last node to 'yesterday'.
sentence->RemoveLast();
sentence->AddLast("yesterday");
Display(sentence, "Test 3: Change the last node to 'yesterday':");
// Move the last node to be the first node.
mark1 = sentence->Last;
sentence->RemoveLast();
sentence->AddFirst(mark1);
Display(sentence, "Test 4: Move last node to be first node:");
// Indicate the last occurence of 'the'.
sentence->RemoveFirst();
LinkedListNode<String^>^ current = sentence->FindLast("the");
IndicateNode(current, "Test 5: Indicate last occurence of 'the':");
// Add 'lazy' and 'old' after 'the' (the LinkedListNode named current).
sentence->AddAfter(current, "old");
sentence->AddAfter(current, "lazy");
IndicateNode(current, "Test 6: Add 'lazy' and 'old' after 'the':");
// Indicate 'fox' node.
current = sentence->Find("fox");
IndicateNode(current, "Test 7: Indicate the 'fox' node:");
// Add 'quick' and 'brown' before 'fox':
sentence->AddBefore(current, "quick");
sentence->AddBefore(current, "brown");
IndicateNode(current, "Test 8: Add 'quick' and 'brown' before 'fox':");
// Keep a reference to the current node, 'fox',
// and to the previous node in the list. Indicate the 'dog' node.
mark1 = current;
LinkedListNode<String^>^ mark2 = current->Previous;
current = sentence->Find("dog");
IndicateNode(current, "Test 9: Indicate the 'dog' node:");
// The AddBefore method throws an InvalidOperationException
// if you try to add a node that already belongs to a list.
Console::WriteLine("Test 10: Throw exception by adding node (fox) already in the list:");
try
{
sentence->AddBefore(current, mark1);
}
catch (InvalidOperationException^ ex)
{
Console::WriteLine("Exception message: {0}", ex->Message);
}
Console::WriteLine();
// Remove the node referred to by mark1, and then add it
// before the node referred to by current.
// Indicate the node referred to by current.
sentence->Remove(mark1);
sentence->AddBefore(current, mark1);
IndicateNode(current, "Test 11: Move a referenced node (fox) before the current node (dog):");
// Remove the node referred to by current.
sentence->Remove(current);
IndicateNode(current, "Test 12: Remove current node (dog) and attempt to indicate it:");
// Add the node after the node referred to by mark2.
sentence->AddAfter(mark2, current);
IndicateNode(current, "Test 13: Add node removed in test 11 after a referenced node (brown):");
// The Remove method finds and removes the
// first node that that has the specified value.
sentence->Remove("old");
Display(sentence, "Test 14: Remove node that has the value 'old':");
// When the linked list is cast to ICollection(Of String),
// the Add method adds a node to the end of the list.
sentence->RemoveLast();
ICollection<String^>^ icoll = sentence;
icoll->Add("rhinoceros");
Display(sentence, "Test 15: Remove last node, cast to ICollection, and add 'rhinoceros':");
Console::WriteLine("Test 16: Copy the list to an array:");
// Create an array with the same number of
// elements as the inked list.
array<String^>^ sArray = gcnew array<String^>(sentence->Count);
sentence->CopyTo(sArray, 0);
for each (String^ s in sArray)
{
Console::WriteLine(s);
}
// Release all the nodes.
sentence->Clear();
Console::WriteLine();
Console::WriteLine("Test 17: Clear linked list. Contains 'jumped' = {0}",
sentence->Contains("jumped"));
Console::ReadLine();
}
private:
static void Display(LinkedList<String^>^ words, String^ test)
{
Console::WriteLine(test);
for each (String^ word in words)
{
Console::Write(word + " ");
}
Console::WriteLine();
Console::WriteLine();
}
static void IndicateNode(LinkedListNode<String^>^ node, String^ test)
{
Console::WriteLine(test);
if (node->List == nullptr)
{
Console::WriteLine("Node '{0}' is not in the list.\n",
node->Value);
return;
}
StringBuilder^ result = gcnew StringBuilder("(" + node->Value + ")");
LinkedListNode<String^>^ nodeP = node->Previous;
while (nodeP != nullptr)
{
result->Insert(0, nodeP->Value + " ");
nodeP = nodeP->Previous;
}
node = node->Next;
while (node != nullptr)
{
result->Append(" " + node->Value);
node = node->Next;
}
Console::WriteLine(result);
Console::WriteLine();
}
};
int main()
{
Example::Main();
}
//This code example produces the following output:
//
//The linked list values:
//the fox jumped over the dog
//Test 1: Add 'today' to beginning of the list:
//today the fox jumped over the dog
//Test 2: Move first node to be last node:
//the fox jumped over the dog today
//Test 3: Change the last node to 'yesterday':
//the fox jumped over the dog yesterday
//Test 4: Move last node to be first node:
//yesterday the fox jumped over the dog
//Test 5: Indicate last occurence of 'the':
//the fox jumped over (the) dog
//Test 6: Add 'lazy' and 'old' after 'the':
//the fox jumped over (the) lazy old dog
//Test 7: Indicate the 'fox' node:
//the (fox) jumped over the lazy old dog
//Test 8: Add 'quick' and 'brown' before 'fox':
//the quick brown (fox) jumped over the lazy old dog
//Test 9: Indicate the 'dog' node:
//the quick brown fox jumped over the lazy old (dog)
//Test 10: Throw exception by adding node (fox) already in the list:
//Exception message: The LinkedList node belongs a LinkedList.
//Test 11: Move a referenced node (fox) before the current node (dog):
//the quick brown jumped over the lazy old fox (dog)
//Test 12: Remove current node (dog) and attempt to indicate it:
//Node 'dog' is not in the list.
//Test 13: Add node removed in test 11 after a referenced node (brown):
//the quick brown (dog) jumped over the lazy old fox
//Test 14: Remove node that has the value 'old':
//the quick brown dog jumped over the lazy fox
//Test 15: Remove last node, cast to ICollection, and add 'rhinoceros':
//the quick brown dog jumped over the lazy rhinoceros
//Test 16: Copy the list to an array:
//the
//quick
//brown
//dog
//jumped
//over
//the
//lazy
//rhinoceros
//Test 17: Clear linked list. Contains 'jumped' = False
//
using System;
using System.Text;
using System.Collections.Generic;
public class Example
{
public static void Main()
{
// Create the link list.
string[] words =
{ "the", "fox", "jumps", "over", "the", "dog" };
LinkedList<string> sentence = new LinkedList<string>(words);
Display(sentence, "The linked list values:");
// Add the word 'today' to the beginning of the linked list.
sentence.AddFirst("today");
Display(sentence, "Test 1: Add 'today' to beginning of the list:");
// Move the first node to be the last node.
LinkedListNode<string> mark1 = sentence.First;
sentence.RemoveFirst();
sentence.AddLast(mark1);
Display(sentence, "Test 2: Move first node to be last node:");
// Change the last node to 'yesterday'.
sentence.RemoveLast();
sentence.AddLast("yesterday");
Display(sentence, "Test 3: Change the last node to 'yesterday':");
// Move the last node to be the first node.
mark1 = sentence.Last;
sentence.RemoveLast();
sentence.AddFirst(mark1);
Display(sentence, "Test 4: Move last node to be first node:");
// Indicate the last occurence of 'the'.
sentence.RemoveFirst();
LinkedListNode<string> current = sentence.FindLast("the");
IndicateNode(current, "Test 5: Indicate last occurence of 'the':");
// Add 'lazy' and 'old' after 'the' (the LinkedListNode named current).
sentence.AddAfter(current, "old");
sentence.AddAfter(current, "lazy");
IndicateNode(current, "Test 6: Add 'lazy' and 'old' after 'the':");
// Indicate 'fox' node.
current = sentence.Find("fox");
IndicateNode(current, "Test 7: Indicate the 'fox' node:");
// Add 'quick' and 'brown' before 'fox':
sentence.AddBefore(current, "quick");
sentence.AddBefore(current, "brown");
IndicateNode(current, "Test 8: Add 'quick' and 'brown' before 'fox':");
// Keep a reference to the current node, 'fox',
// and to the previous node in the list. Indicate the 'dog' node.
mark1 = current;
LinkedListNode<string> mark2 = current.Previous;
current = sentence.Find("dog");
IndicateNode(current, "Test 9: Indicate the 'dog' node:");
// The AddBefore method throws an InvalidOperationException
// if you try to add a node that already belongs to a list.
Console.WriteLine("Test 10: Throw exception by adding node (fox) already in the list:");
try
{
sentence.AddBefore(current, mark1);
}
catch (InvalidOperationException ex)
{
Console.WriteLine("Exception message: {0}", ex.Message);
}
Console.WriteLine();
// Remove the node referred to by mark1, and then add it
// before the node referred to by current.
// Indicate the node referred to by current.
sentence.Remove(mark1);
sentence.AddBefore(current, mark1);
IndicateNode(current, "Test 11: Move a referenced node (fox) before the current node (dog):");
// Remove the node referred to by current.
sentence.Remove(current);
IndicateNode(current, "Test 12: Remove current node (dog) and attempt to indicate it:");
// Add the node after the node referred to by mark2.
sentence.AddAfter(mark2, current);
IndicateNode(current, "Test 13: Add node removed in test 11 after a referenced node (brown):");
// The Remove method finds and removes the
// first node that that has the specified value.
sentence.Remove("old");
Display(sentence, "Test 14: Remove node that has the value 'old':");
// When the linked list is cast to ICollection(Of String),
// the Add method adds a node to the end of the list.
sentence.RemoveLast();
ICollection<string> icoll = sentence;
icoll.Add("rhinoceros");
Display(sentence, "Test 15: Remove last node, cast to ICollection, and add 'rhinoceros':");
Console.WriteLine("Test 16: Copy the list to an array:");
// Create an array with the same number of
// elements as the linked list.
string[] sArray = new string[sentence.Count];
sentence.CopyTo(sArray, 0);
foreach (string s in sArray)
{
Console.WriteLine(s);
}
Console.WriteLine("Test 17: linked list Contains 'jumps' = {0}",
sentence.Contains("jumps"));
// Release all the nodes.
sentence.Clear();
Console.WriteLine();
Console.WriteLine("Test 18: Cleared linked list Contains 'jumps' = {0}",
sentence.Contains("jumps"));
Console.ReadLine();
}
private static void Display(LinkedList<string> words, string test)
{
Console.WriteLine(test);
foreach (string word in words)
{
Console.Write(word + " ");
}
Console.WriteLine();
Console.WriteLine();
}
private static void IndicateNode(LinkedListNode<string> node, string test)
{
Console.WriteLine(test);
if (node.List == null)
{
Console.WriteLine("Node '{0}' is not in the list.\n",
node.Value);
return;
}
StringBuilder result = new StringBuilder("(" + node.Value + ")");
LinkedListNode<string> nodeP = node.Previous;
while (nodeP != null)
{
result.Insert(0, nodeP.Value + " ");
nodeP = nodeP.Previous;
}
node = node.Next;
while (node != null)
{
result.Append(" " + node.Value);
node = node.Next;
}
Console.WriteLine(result);
Console.WriteLine();
}
}
//This code example produces the following output:
//
//The linked list values:
//the fox jumps over the dog
//Test 1: Add 'today' to beginning of the list:
//today the fox jumps over the dog
//Test 2: Move first node to be last node:
//the fox jumps over the dog today
//Test 3: Change the last node to 'yesterday':
//the fox jumps over the dog yesterday
//Test 4: Move last node to be first node:
//yesterday the fox jumps over the dog
//Test 5: Indicate last occurence of 'the':
//the fox jumps over (the) dog
//Test 6: Add 'lazy' and 'old' after 'the':
//the fox jumps over (the) lazy old dog
//Test 7: Indicate the 'fox' node:
//the (fox) jumps over the lazy old dog
//Test 8: Add 'quick' and 'brown' before 'fox':
//the quick brown (fox) jumps over the lazy old dog
//Test 9: Indicate the 'dog' node:
//the quick brown fox jumps over the lazy old (dog)
//Test 10: Throw exception by adding node (fox) already in the list:
//Exception message: The LinkedList node belongs a LinkedList.
//Test 11: Move a referenced node (fox) before the current node (dog):
//the quick brown jumps over the lazy old fox (dog)
//Test 12: Remove current node (dog) and attempt to indicate it:
//Node 'dog' is not in the list.
//Test 13: Add node removed in test 11 after a referenced node (brown):
//the quick brown (dog) jumps over the lazy old fox
//Test 14: Remove node that has the value 'old':
//the quick brown dog jumps over the lazy fox
//Test 15: Remove last node, cast to ICollection, and add 'rhinoceros':
//the quick brown dog jumps over the lazy rhinoceros
//Test 16: Copy the list to an array:
//the
//quick
//brown
//dog
//jumps
//over
//the
//lazy
//rhinoceros
//Test 17: linked list Contains 'jumps'= True
//Test 18: Cleared linked list Contains 'jumps' = False
//
Imports System.Text
Imports System.Collections.Generic
Public Class Example
Public Shared Sub Main()
' Create the link list.
Dim words() As String = {"the", "fox", _
"jumps", "over", "the", "dog"}
Dim sentence As New LinkedList(Of String)(words)
Console.WriteLine("sentence.Contains(""jumps"") = {0}", _
sentence.Contains("jumps"))
Display(sentence, "The linked list values:")
' Add the word 'today' to the beginning of the linked list.
sentence.AddFirst("today")
Display(sentence, "Test 1: Add 'today' to beginning of the list:")
' Move the first node to be the last node.
Dim mark1 As LinkedListNode(Of String) = sentence.First
sentence.RemoveFirst()
sentence.AddLast(mark1)
Display(sentence, "Test 2: Move first node to be last node:")
' Change the last node to 'yesterday'.
sentence.RemoveLast()
sentence.AddLast("yesterday")
Display(sentence, "Test 3: Change the last node to 'yesterday':")
' Move the last node to be the first node.
mark1 = sentence.Last
sentence.RemoveLast()
sentence.AddFirst(mark1)
Display(sentence, "Test 4: Move last node to be first node:")
' Indicate the last occurence of 'the'.
sentence.RemoveFirst()
Dim current As LinkedListNode(Of String) = sentence.FindLast("the")
IndicateNode(current, "Test 5: Indicate last occurence of 'the':")
' Add 'lazy' and 'old' after 'the' (the LinkedListNode named current).
sentence.AddAfter(current, "old")
sentence.AddAfter(current, "lazy")
IndicateNode(current, "Test 6: Add 'lazy' and 'old' after 'the':")
' Indicate 'fox' node.
current = sentence.Find("fox")
IndicateNode(current, "Test 7: Indicate the 'fox' node:")
' Add 'quick' and 'brown' before 'fox':
sentence.AddBefore(current, "quick")
sentence.AddBefore(current, "brown")
IndicateNode(current, "Test 8: Add 'quick' and 'brown' before 'fox':")
' Keep a reference to the current node, 'fox',
' and to the previous node in the list. Indicate the 'dog' node.
mark1 = current
Dim mark2 As LinkedListNode(Of String) = current.Previous
current = sentence.Find("dog")
IndicateNode(current, "Test 9: Indicate the 'dog' node:")
' The AddBefore method throws an InvalidOperationException
' if you try to add a node that already belongs to a list.
Console.WriteLine("Test 10: Throw exception by adding node (fox) already in the list:")
Try
sentence.AddBefore(current, mark1)
Catch ex As InvalidOperationException
Console.WriteLine("Exception message: {0}", ex.Message)
End Try
Console.WriteLine()
' Remove the node referred to by mark1, and then add it
' before the node referred to by current.
' Indicate the node referred to by current.
sentence.Remove(mark1)
sentence.AddBefore(current, mark1)
IndicateNode(current, "Test 11: Move a referenced node (fox) before the current node (dog):")
' Remove the node referred to by current.
sentence.Remove(current)
IndicateNode(current, "Test 12: Remove current node (dog) and attempt to indicate it:")
' Add the node after the node referred to by mark2.
sentence.AddAfter(mark2, current)
IndicateNode(current, "Test 13: Add node removed in test 11 after a referenced node (brown):")
' The Remove method finds and removes the
' first node that that has the specified value.
sentence.Remove("old")
Display(sentence, "Test 14: Remove node that has the value 'old':")
' When the linked list is cast to ICollection(Of String),
' the Add method adds a node to the end of the list.
sentence.RemoveLast()
Dim icoll As ICollection(Of String) = sentence
icoll.Add("rhinoceros")
Display(sentence, "Test 15: Remove last node, cast to ICollection, and add 'rhinoceros':")
Console.WriteLine("Test 16: Copy the list to an array:")
' Create an array with the same number of
' elements as the inked list.
Dim sArray() As String = New String((sentence.Count) - 1) {}
sentence.CopyTo(sArray, 0)
For Each s As String In sArray
Console.WriteLine(s)
Next
' Release all the nodes.
sentence.Clear()
Console.WriteLine()
Console.WriteLine("Test 17: Clear linked list. Contains 'jumps' = {0}", sentence.Contains("jumps"))
Console.ReadLine()
End Sub
Private Shared Sub Display(ByVal words As LinkedList(Of String), ByVal test As String)
Console.WriteLine(test)
For Each word As String In words
Console.Write((word + " "))
Next
Console.WriteLine()
Console.WriteLine()
End Sub
Private Shared Sub IndicateNode(ByVal node As LinkedListNode(Of String), ByVal test As String)
Console.WriteLine(test)
If IsNothing(node.List) Then
Console.WriteLine("Node '{0}' is not in the list." & vbLf, node.Value)
Return
End If
Dim result As StringBuilder = New StringBuilder(("(" _
+ (node.Value + ")")))
Dim nodeP As LinkedListNode(Of String) = node.Previous
While (Not (nodeP) Is Nothing)
result.Insert(0, (nodeP.Value + " "))
nodeP = nodeP.Previous
End While
node = node.Next
While (Not (node) Is Nothing)
result.Append((" " + node.Value))
node = node.Next
End While
Console.WriteLine(result)
Console.WriteLine()
End Sub
End Class
'This code example produces the following output:
'
'The linked list values:
'the fox jumps over the dog
'Test 1: Add 'today' to beginning of the list:
'today the fox jumps over the dog
'Test 2: Move first node to be last node:
'the fox jumps over the dog today
'Test 3: Change the last node to 'yesterday':
'the fox jumps over the dog yesterday
'Test 4: Move last node to be first node:
'yesterday the fox jumps over the dog
'Test 5: Indicate last occurence of 'the':
'the fox jumps over (the) dog
'Test 6: Add 'lazy' and 'old' after 'the':
'the fox jumps over (the) lazy old dog
'Test 7: Indicate the 'fox' node:
'the (fox) jumps over the lazy old dog
'Test 8: Add 'quick' and 'brown' before 'fox':
'the quick brown (fox) jumps over the lazy old dog
'Test 9: Indicate the 'dog' node:
'the quick brown fox jumps over the lazy old (dog)
'Test 10: Throw exception by adding node (fox) already in the list:
'Exception message: The LinkedList node belongs a LinkedList.
'Test 11: Move a referenced node (fox) before the current node (dog):
'the quick brown jumps over the lazy old fox (dog)
'Test 12: Remove current node (dog) and attempt to indicate it:
'Node 'dog' is not in the list.
'Test 13: Add node removed in test 11 after a referenced node (brown):
'the quick brown (dog) jumps over the lazy old fox
'Test 14: Remove node that has the value 'old':
'the quick brown dog jumps over the lazy fox
'Test 15: Remove last node, cast to ICollection, and add 'rhinoceros':
'the quick brown dog jumps over the lazy rhinoceros
'Test 16: Copy the list to an array:
'the
'quick
'brown
'dog
'jumps
'over
'the
'lazy
'rhinoceros
'Test 17: Clear linked list. Contains 'jumps' = False
'
Hinweise
LinkedList<T> ist eine allgemeine verknüpfte Liste. Es unterstützt Enumerationen und implementiert die ICollection Schnittstelle, die mit anderen Sammlungsklassen in .NET Framework konsistent ist.
LinkedList<T> stellt separate Knoten vom Typ LinkedListNode<T>bereit, sodass ein- und entfernte Vorgänge O(1) sind.
Sie können Knoten entfernen und erneut einfügen, entweder in derselben Liste oder in einer anderen Liste, was zu keinen zusätzlichen Objekten führt, die dem Heap zugeordnet sind. Da die Liste auch eine interne Anzahl verwaltet, ist das Abrufen der Count-Eigenschaft ein O(1)-Vorgang.
Jeder Knoten in einem LinkedList<T>-Objekt weist den Typ LinkedListNode<T>auf. Da die LinkedList<T> doubly verknüpft ist, zeigt jeder Knoten vorwärts auf den Next Knoten und rückwärts zum Previous Knoten.
Listen, die Referenztypen enthalten, können besser ausgeführt werden, wenn ein Knoten und sein Wert gleichzeitig erstellt werden.
LinkedList<T> akzeptiert null
als gültige Value-Eigenschaft für Verweistypen und lässt doppelte Werte zu.
Wenn die LinkedList<T> leer ist, enthalten die eigenschaften First und Lastnull
.
Die LinkedList<T>-Klasse unterstützt keine Verkettung, Aufteilung, Zyklen oder andere Features, die die Liste in einem inkonsistenten Zustand belassen können. Die Liste bleibt in einem einzelnen Thread konsistent. Das einzige von LinkedList<T> unterstützte Multithread-Szenario ist Multithreadlesevorgänge.
Konstruktoren
LinkedList<T>() |
Initialisiert eine neue Instanz der LinkedList<T> Klasse, die leer ist. |
LinkedList<T>(IEnumerable<T>) |
Initialisiert eine neue Instanz der LinkedList<T> Klasse, die Elemente enthält, die aus dem angegebenen IEnumerable kopiert wurden, und verfügt über ausreichende Kapazität, um die Anzahl der kopierten Elemente zu berücksichtigen. |
LinkedList<T>(SerializationInfo, StreamingContext) |
Veraltet.
Initialisiert eine neue Instanz der LinkedList<T> Klasse, die mit dem angegebenen SerializationInfo und StreamingContextserialisierbar ist. |
Eigenschaften
Count |
Ruft die Anzahl der Knoten ab, die tatsächlich in der LinkedList<T>enthalten sind. |
First |
Ruft den ersten Knoten des LinkedList<T>ab. |
Last |
Ruft den letzten Knoten der LinkedList<T>ab. |
Methoden
AddAfter(LinkedListNode<T>, LinkedListNode<T>) |
Fügt den angegebenen neuen Knoten nach dem angegebenen vorhandenen Knoten im LinkedList<T>hinzu. |
AddAfter(LinkedListNode<T>, T) |
Fügt einen neuen Knoten hinzu, der den angegebenen Wert nach dem angegebenen vorhandenen Knoten im LinkedList<T>enthält. |
AddBefore(LinkedListNode<T>, LinkedListNode<T>) |
Fügt den angegebenen neuen Knoten vor dem angegebenen vorhandenen Knoten im LinkedList<T>hinzu. |
AddBefore(LinkedListNode<T>, T) |
Fügt einen neuen Knoten hinzu, der den angegebenen Wert vor dem angegebenen vorhandenen Knoten im LinkedList<T>enthält. |
AddFirst(LinkedListNode<T>) |
Fügt den angegebenen neuen Knoten am Anfang des LinkedList<T>hinzu. |
AddFirst(T) |
Fügt einen neuen Knoten hinzu, der den angegebenen Wert am Anfang der LinkedList<T>enthält. |
AddLast(LinkedListNode<T>) |
Fügt den angegebenen neuen Knoten am Ende der LinkedList<T>hinzu. |
AddLast(T) |
Fügt einen neuen Knoten hinzu, der den angegebenen Wert am Ende der LinkedList<T>enthält. |
Clear() |
Entfernt alle Knoten aus dem LinkedList<T>. |
Contains(T) |
Bestimmt, ob sich ein Wert im LinkedList<T>befindet. |
CopyTo(T[], Int32) |
Kopiert die gesamte LinkedList<T> in eine kompatible eindimensionale Arrayab dem angegebenen Index des Zielarrays. |
Equals(Object) |
Bestimmt, ob das angegebene Objekt dem aktuellen Objekt entspricht. (Geerbt von Object) |
Find(T) |
Sucht den ersten Knoten, der den angegebenen Wert enthält. |
FindLast(T) |
Sucht den letzten Knoten, der den angegebenen Wert enthält. |
GetEnumerator() |
Gibt einen Enumerator zurück, der durch die LinkedList<T>durchläuft. |
GetHashCode() |
Dient als Standardhashfunktion. (Geerbt von Object) |
GetObjectData(SerializationInfo, StreamingContext) |
Veraltet.
Implementiert die ISerializable Schnittstelle und gibt die zum Serialisieren der LinkedList<T> Instanz erforderlichen Daten zurück. |
GetType() |
Ruft die Type der aktuellen Instanz ab. (Geerbt von Object) |
MemberwiseClone() |
Erstellt eine flache Kopie der aktuellen Object. (Geerbt von Object) |
OnDeserialization(Object) |
Implementiert die ISerializable Schnittstelle und löst das Deserialisierungsereignis aus, wenn die Deserialisierung abgeschlossen ist. |
Remove(LinkedListNode<T>) |
Entfernt den angegebenen Knoten aus dem LinkedList<T>. |
Remove(T) |
Entfernt das erste Vorkommen des angegebenen Werts aus dem LinkedList<T>. |
RemoveFirst() |
Entfernt den Knoten am Anfang der LinkedList<T>. |
RemoveLast() |
Entfernt den Knoten am Ende der LinkedList<T>. |
ToString() |
Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object) |
Explizite Schnittstellenimplementierungen
ICollection.CopyTo(Array, Int32) |
Kopiert die Elemente des ICollection in einen Array, beginnend bei einem bestimmten Array Index. |
ICollection.IsSynchronized |
Ruft einen Wert ab, der angibt, ob der Zugriff auf die ICollection synchronisiert wird (Threadsicher). |
ICollection.SyncRoot |
Ruft ein Objekt ab, das zum Synchronisieren des Zugriffs auf die ICollectionverwendet werden kann. |
ICollection<T>.Add(T) |
Fügt am Ende der ICollection<T>ein Element hinzu. |
ICollection<T>.IsReadOnly |
Ruft einen Wert ab, der angibt, ob die ICollection<T> schreibgeschützt ist. |
IEnumerable.GetEnumerator() |
Gibt einen Enumerator zurück, der die verknüpfte Liste als Auflistung durchläuft. |
IEnumerable<T>.GetEnumerator() |
Gibt einen Enumerator zurück, der eine Auflistung durchläuft. |
Erweiterungsmethoden
ToFrozenDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) |
Erstellt eine FrozenDictionary<TKey,TValue> aus einer IEnumerable<T> entsprechend der angegebenen Tastenauswahlfunktion. |
ToFrozenDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>) |
Erstellt eine FrozenDictionary<TKey,TValue> aus einer IEnumerable<T> gemäß den angegebenen Schlüsselauswahl- und Elementauswahlfunktionen. |
ToFrozenSet<T>(IEnumerable<T>, IEqualityComparer<T>) |
Erstellt eine FrozenSet<T> mit den angegebenen Werten. |
ToImmutableArray<TSource>(IEnumerable<TSource>) |
Erstellt ein unveränderliches Array aus der angegebenen Auflistung. |
ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) |
Erstellt ein unveränderliches Wörterbuch aus einer vorhandenen Auflistung von Elementen, wobei eine Transformationsfunktion auf die Quellschlüssel angewendet wird. |
ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) |
Erstellt ein unveränderliches Wörterbuch basierend auf einer Transformation einer Sequenz. |
ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>) |
Enumeiert und transformiert eine Sequenz und erzeugt ein unveränderliches Wörterbuch seiner Inhalte. |
ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>) |
Enumeiert und transformiert eine Sequenz und erzeugt ein unveränderliches Wörterbuch seiner Inhalte mithilfe des angegebenen Schlüsselabgleichs. |
ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>, IEqualityComparer<TValue>) |
Enumeiert und transformiert eine Sequenz und erzeugt ein unveränderliches Wörterbuch seiner Inhalte mithilfe des angegebenen Schlüssel- und Wertabgleichs. |
ToImmutableHashSet<TSource>(IEnumerable<TSource>) |
Listet eine Sequenz auf und erzeugt einen unveränderlichen Hashsatz seiner Inhalte. |
ToImmutableHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>) |
Listet eine Sequenz auf, erzeugt einen unveränderlichen Hashsatz seines Inhalts und verwendet den angegebenen Gleichheitsabgleich für den Settyp. |
ToImmutableList<TSource>(IEnumerable<TSource>) |
Listet eine Sequenz auf und erzeugt eine unveränderliche Liste seiner Inhalte. |
ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>) |
Enumeiert und transformiert eine Sequenz und erzeugt ein unveränderliches sortiertes Wörterbuch seiner Inhalte. |
ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>) |
Enumeiert und transformiert eine Sequenz und erzeugt ein unveränderliches sortiertes Wörterbuch seiner Inhalte mithilfe des angegebenen Schlüsselabgleichs. |
ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>, IEqualityComparer<TValue>) |
Enumeiert und transformiert eine Sequenz und erzeugt ein unveränderliches sortiertes Wörterbuch seiner Inhalte mithilfe des angegebenen Schlüssel- und Wertabgleichs. |
ToImmutableSortedSet<TSource>(IEnumerable<TSource>) |
Listet eine Sequenz auf und erzeugt einen unveränderlichen sortierten Satz seiner Inhalte. |
ToImmutableSortedSet<TSource>(IEnumerable<TSource>, IComparer<TSource>) |
Listet eine Sequenz auf, erzeugt einen unveränderlichen sortierten Satz seines Inhalts und verwendet den angegebenen Vergleich. |
CopyToDataTable<T>(IEnumerable<T>) |
Gibt einen DataTable zurück, der Kopien der DataRow -Objekte enthält, vorausgesetzt, ein Eingabeobjekt IEnumerable<T>, bei dem der generische Parameter |
CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption) |
Kopiert DataRow Objekte in den angegebenen DataTable, wenn ein Eingabeobjekt IEnumerable<T> objekt, wobei der generische Parameter |
CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler) |
Kopiert DataRow Objekte in den angegebenen DataTable, wenn ein Eingabeobjekt IEnumerable<T> objekt, wobei der generische Parameter |
Aggregate<TSource>(IEnumerable<TSource>, Func<TSource,TSource,TSource>) |
Wendet eine Akkumulatorfunktion auf eine Sequenz an. |
Aggregate<TSource,TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>) |
Wendet eine Akkumulatorfunktion auf eine Sequenz an. Der angegebene Ausgangswert wird als anfänglicher Akkumulatorwert verwendet. |
Aggregate<TSource,TAccumulate,TResult>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>, Func<TAccumulate,TResult>) |
Wendet eine Akkumulatorfunktion auf eine Sequenz an. Der angegebene Ausgangswert wird als anfänglicher Akkumulatorwert verwendet, und die angegebene Funktion wird verwendet, um den Ergebniswert auszuwählen. |
AggregateBy<TSource,TKey,TAccumulate>(IEnumerable<TSource>, Func<TSource, TKey>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>, IEqualityComparer<TKey>) |
Stellt eine doubly verknüpfte Liste dar. |
AggregateBy<TSource,TKey,TAccumulate>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TKey,TAccumulate>, Func<TAccumulate,TSource,TAccumulate>, IEqualityComparer<TKey>) |
Stellt eine doubly verknüpfte Liste dar. |
All<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Bestimmt, ob alle Elemente einer Sequenz eine Bedingung erfüllen. |
Any<TSource>(IEnumerable<TSource>) |
Bestimmt, ob eine Sequenz Elemente enthält. |
Any<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Bestimmt, ob ein Element einer Sequenz eine Bedingung erfüllt. |
Append<TSource>(IEnumerable<TSource>, TSource) |
Fügt einen Wert an das Ende der Sequenz an. |
AsEnumerable<TSource>(IEnumerable<TSource>) |
Gibt die eingegebene Eingabe als IEnumerable<T>zurück. |
Average<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>) |
Berechnet den Mittelwert einer Sequenz von Decimal Werten, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden. |
Average<TSource>(IEnumerable<TSource>, Func<TSource,Double>) |
Berechnet den Mittelwert einer Sequenz von Double Werten, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden. |
Average<TSource>(IEnumerable<TSource>, Func<TSource,Int32>) |
Berechnet den Mittelwert einer Sequenz von Int32 Werten, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden. |
Average<TSource>(IEnumerable<TSource>, Func<TSource,Int64>) |
Berechnet den Mittelwert einer Sequenz von Int64 Werten, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden. |
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>) |
Berechnet den Mittelwert einer Sequenz nullabler Decimal Werte, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden. |
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>) |
Berechnet den Mittelwert einer Sequenz nullabler Double Werte, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden. |
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>) |
Berechnet den Mittelwert einer Sequenz nullabler Int32 Werte, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden. |
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>) |
Berechnet den Mittelwert einer Sequenz nullabler Int64 Werte, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden. |
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>) |
Berechnet den Mittelwert einer Sequenz nullabler Single Werte, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden. |
Average<TSource>(IEnumerable<TSource>, Func<TSource,Single>) |
Berechnet den Mittelwert einer Sequenz von Single Werten, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden. |
Cast<TResult>(IEnumerable) |
Wandelt die Elemente eines IEnumerable in den angegebenen Typ um. |
Chunk<TSource>(IEnumerable<TSource>, Int32) |
Teilt die Elemente einer Sequenz in Teile der Größe auf, die höchstens |
Concat<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) |
Verkettet zwei Sequenzen. |
Contains<TSource>(IEnumerable<TSource>, TSource) |
Bestimmt, ob eine Sequenz ein angegebenes Element mithilfe des Standardmäßigen Gleichheitsabgleichs enthält. |
Contains<TSource>(IEnumerable<TSource>, TSource, IEqualityComparer<TSource>) |
Bestimmt, ob eine Sequenz ein angegebenes Element enthält, indem ein angegebenes IEqualityComparer<T>verwendet wird. |
Count<TSource>(IEnumerable<TSource>) |
Gibt die Anzahl der Elemente in einer Sequenz zurück. |
Count<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Gibt eine Zahl zurück, die angibt, wie viele Elemente in der angegebenen Sequenz eine Bedingung erfüllen. |
CountBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) |
Stellt eine doubly verknüpfte Liste dar. |
DefaultIfEmpty<TSource>(IEnumerable<TSource>) |
Gibt die Elemente der angegebenen Sequenz oder des Standardwerts des Typparameters in einer Singleton -Auflistung zurück, wenn die Sequenz leer ist. |
DefaultIfEmpty<TSource>(IEnumerable<TSource>, TSource) |
Gibt die Elemente der angegebenen Sequenz oder den angegebenen Wert in einer Singleton -Auflistung zurück, wenn die Sequenz leer ist. |
Distinct<TSource>(IEnumerable<TSource>) |
Gibt unterschiedliche Elemente aus einer Sequenz zurück, indem der Standardgleichstellungsabgleich verwendet wird, um Werte zu vergleichen. |
Distinct<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>) |
Gibt unterschiedliche Elemente aus einer Sequenz zurück, indem ein angegebenes IEqualityComparer<T> zum Vergleichen von Werten verwendet wird. |
DistinctBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) |
Gibt unterschiedliche Elemente aus einer Sequenz gemäß einer angegebenen Schlüsselauswahlfunktion zurück. |
DistinctBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) |
Gibt unterschiedliche Elemente aus einer Sequenz gemäß einer angegebenen Schlüsselmarkierfunktion zurück und verwendet einen angegebenen Vergleich zum Vergleichen von Tasten. |
ElementAt<TSource>(IEnumerable<TSource>, Index) |
Gibt das Element an einem angegebenen Index in einer Sequenz zurück. |
ElementAt<TSource>(IEnumerable<TSource>, Int32) |
Gibt das Element an einem angegebenen Index in einer Sequenz zurück. |
ElementAtOrDefault<TSource>(IEnumerable<TSource>, Index) |
Gibt das Element an einem angegebenen Index in einer Sequenz oder einem Standardwert zurück, wenn der Index außerhalb des Bereichs liegt. |
ElementAtOrDefault<TSource>(IEnumerable<TSource>, Int32) |
Gibt das Element an einem angegebenen Index in einer Sequenz oder einem Standardwert zurück, wenn der Index außerhalb des Bereichs liegt. |
Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) |
Erzeugt den Satzunterschied von zwei Sequenzen mithilfe des Standardgleichgleichsabgleichs zum Vergleichen von Werten. |
Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>) |
Erzeugt den Satzunterschied zweier Sequenzen mithilfe der angegebenen IEqualityComparer<T> zum Vergleichen von Werten. |
ExceptBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>) |
Erzeugt den Satzunterschied von zwei Sequenzen gemäß einer angegebenen Schlüsselmarkierfunktion. |
ExceptBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>, IEqualityComparer<TKey>) |
Erzeugt den Satzunterschied von zwei Sequenzen gemäß einer angegebenen Schlüsselmarkierfunktion. |
First<TSource>(IEnumerable<TSource>) |
Gibt das erste Element einer Sequenz zurück. |
First<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Gibt das erste Element in einer Sequenz zurück, das eine angegebene Bedingung erfüllt. |
FirstOrDefault<TSource>(IEnumerable<TSource>) |
Gibt das erste Element einer Sequenz oder einen Standardwert zurück, wenn die Sequenz keine Elemente enthält. |
FirstOrDefault<TSource>(IEnumerable<TSource>, TSource) |
Gibt das erste Element einer Sequenz oder einen angegebenen Standardwert zurück, wenn die Sequenz keine Elemente enthält. |
FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Gibt das erste Element der Sequenz zurück, das eine Bedingung oder einen Standardwert erfüllt, wenn kein solches Element gefunden wird. |
FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource) |
Gibt das erste Element der Sequenz zurück, das eine Bedingung erfüllt, oder einen angegebenen Standardwert, wenn kein solches Element gefunden wird. |
GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) |
Gruppiert die Elemente einer Sequenz entsprechend einer angegebenen Schlüsselauswahlfunktion. |
GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) |
Gruppiert die Elemente einer Sequenz entsprechend einer angegebenen Schlüsselauswahlfunktion und vergleicht die Tasten mithilfe eines angegebenen Vergleichs. |
GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>) |
Gruppiert die Elemente einer Sequenz entsprechend einer angegebenen Schlüsselauswahlfunktion und projiziert die Elemente für jede Gruppe mithilfe einer angegebenen Funktion. |
GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>) |
Gruppiert die Elemente einer Sequenz entsprechend einer Tastenauswahlfunktion. Die Schlüssel werden mithilfe eines Vergleichs verglichen, und die Elemente jeder Gruppe werden mithilfe einer angegebenen Funktion projiziert. |
GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>) |
Gruppiert die Elemente einer Sequenz entsprechend einer angegebenen Schlüsselmarkierfunktion und erstellt einen Ergebniswert aus jeder Gruppe und dem zugehörigen Schlüssel. |
GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>, IEqualityComparer<TKey>) |
Gruppiert die Elemente einer Sequenz entsprechend einer angegebenen Schlüsselmarkierfunktion und erstellt einen Ergebniswert aus jeder Gruppe und dem zugehörigen Schlüssel. Die Schlüssel werden mithilfe eines angegebenen Vergleichs verglichen. |
GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>) |
Gruppiert die Elemente einer Sequenz entsprechend einer angegebenen Schlüsselmarkierfunktion und erstellt einen Ergebniswert aus jeder Gruppe und dem zugehörigen Schlüssel. Die Elemente jeder Gruppe werden mithilfe einer angegebenen Funktion projiziert. |
GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>, TResult>, IEqualityComparer<TKey>) |
Gruppiert die Elemente einer Sequenz entsprechend einer angegebenen Schlüsselmarkierfunktion und erstellt einen Ergebniswert aus jeder Gruppe und dem zugehörigen Schlüssel. Schlüsselwerte werden mithilfe eines angegebenen Vergleichs verglichen, und die Elemente jeder Gruppe werden mithilfe einer angegebenen Funktion projiziert. |
GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>, TResult>) |
Korreliert die Elemente zweier Sequenzen basierend auf der Gleichheit von Schlüsseln und gruppiert die Ergebnisse. Der Standardmäßige Gleichheitsvergleich wird zum Vergleichen von Schlüsseln verwendet. |
GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>, TResult>, IEqualityComparer<TKey>) |
Korreliert die Elemente zweier Sequenzen basierend auf schlüsselgleicher Gleichheit und gruppiert die Ergebnisse. Ein angegebenes IEqualityComparer<T> wird zum Vergleichen von Schlüsseln verwendet. |
Index<TSource>(IEnumerable<TSource>) |
Gibt eine Aufzählung zurück, die den Index des Elements in ein Tupel einschließt. |
Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) |
Erzeugt die festgelegte Schnittmenge von zwei Sequenzen mithilfe des Standardgleichgleichsabgleichs zum Vergleichen von Werten. |
Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>) |
Erzeugt die festgelegte Schnittmenge von zwei Sequenzen mithilfe der angegebenen IEqualityComparer<T> zum Vergleichen von Werten. |
IntersectBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>) |
Erzeugt die festgelegte Schnittmenge von zwei Sequenzen gemäß einer angegebenen Schlüsselmarkierfunktion. |
IntersectBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>, IEqualityComparer<TKey>) |
Erzeugt die festgelegte Schnittmenge von zwei Sequenzen gemäß einer angegebenen Schlüsselmarkierfunktion. |
Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>) |
Korreliert die Elemente zweier Sequenzen basierend auf übereinstimmenden Schlüsseln. Der Standardmäßige Gleichheitsvergleich wird zum Vergleichen von Schlüsseln verwendet. |
Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>, IEqualityComparer<TKey>) |
Korreliert die Elemente zweier Sequenzen basierend auf übereinstimmenden Schlüsseln. Ein angegebenes IEqualityComparer<T> wird zum Vergleichen von Schlüsseln verwendet. |
Last<TSource>(IEnumerable<TSource>) |
Gibt das letzte Element einer Sequenz zurück. |
Last<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Gibt das letzte Element einer Sequenz zurück, das eine angegebene Bedingung erfüllt. |
LastOrDefault<TSource>(IEnumerable<TSource>) |
Gibt das letzte Element einer Sequenz oder einen Standardwert zurück, wenn die Sequenz keine Elemente enthält. |
LastOrDefault<TSource>(IEnumerable<TSource>, TSource) |
Gibt das letzte Element einer Sequenz oder einen angegebenen Standardwert zurück, wenn die Sequenz keine Elemente enthält. |
LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Gibt das letzte Element einer Sequenz zurück, das eine Bedingung oder einen Standardwert erfüllt, wenn kein solches Element gefunden wird. |
LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource) |
Gibt das letzte Element einer Sequenz zurück, das eine Bedingung erfüllt, oder einen angegebenen Standardwert, wenn kein solches Element gefunden wird. |
LongCount<TSource>(IEnumerable<TSource>) |
Gibt einen Int64 zurück, der die Gesamtanzahl der Elemente in einer Sequenz darstellt. |
LongCount<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Gibt einen Int64 zurück, der angibt, wie viele Elemente in einer Sequenz eine Bedingung erfüllen. |
Max<TSource>(IEnumerable<TSource>) |
Gibt den Maximalwert in einer generischen Sequenz zurück. |
Max<TSource>(IEnumerable<TSource>, IComparer<TSource>) |
Gibt den Maximalwert in einer generischen Sequenz zurück. |
Max<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>) |
Ruft eine Transformationsfunktion für jedes Element einer Sequenz auf und gibt den maximalen Decimal Wert zurück. |
Max<TSource>(IEnumerable<TSource>, Func<TSource,Double>) |
Ruft eine Transformationsfunktion für jedes Element einer Sequenz auf und gibt den maximalen Double Wert zurück. |
Max<TSource>(IEnumerable<TSource>, Func<TSource,Int32>) |
Ruft eine Transformationsfunktion für jedes Element einer Sequenz auf und gibt den maximalen Int32 Wert zurück. |
Max<TSource>(IEnumerable<TSource>, Func<TSource,Int64>) |
Ruft eine Transformationsfunktion für jedes Element einer Sequenz auf und gibt den maximalen Int64 Wert zurück. |
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>) |
Ruft eine Transformationsfunktion für jedes Element einer Sequenz auf und gibt den maximal nullfähigen Decimal Wert zurück. |
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>) |
Ruft eine Transformationsfunktion für jedes Element einer Sequenz auf und gibt den maximal nullfähigen Double Wert zurück. |
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>) |
Ruft eine Transformationsfunktion für jedes Element einer Sequenz auf und gibt den maximal nullfähigen Int32 Wert zurück. |
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>) |
Ruft eine Transformationsfunktion für jedes Element einer Sequenz auf und gibt den maximal nullfähigen Int64 Wert zurück. |
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>) |
Ruft eine Transformationsfunktion für jedes Element einer Sequenz auf und gibt den maximal nullfähigen Single Wert zurück. |
Max<TSource>(IEnumerable<TSource>, Func<TSource,Single>) |
Ruft eine Transformationsfunktion für jedes Element einer Sequenz auf und gibt den maximalen Single Wert zurück. |
Max<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>) |
Ruft eine Transformationsfunktion für jedes Element einer generischen Sequenz auf und gibt den maximal resultierenden Wert zurück. |
MaxBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) |
Gibt den Maximalwert in einer generischen Sequenz gemäß einer angegebenen Schlüsselmarkierfunktion zurück. |
MaxBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>) |
Gibt den Maximalwert in einer generischen Sequenz gemäß einer angegebenen Schlüsselmarkierfunktion und einem Schlüsselabgleich zurück. |
Min<TSource>(IEnumerable<TSource>) |
Gibt den Minimalwert in einer generischen Sequenz zurück. |
Min<TSource>(IEnumerable<TSource>, IComparer<TSource>) |
Gibt den Minimalwert in einer generischen Sequenz zurück. |
Min<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>) |
Ruft eine Transformationsfunktion für jedes Element einer Sequenz auf und gibt den minimalen Decimal Wert zurück. |
Min<TSource>(IEnumerable<TSource>, Func<TSource,Double>) |
Ruft eine Transformationsfunktion für jedes Element einer Sequenz auf und gibt den minimalen Double Wert zurück. |
Min<TSource>(IEnumerable<TSource>, Func<TSource,Int32>) |
Ruft eine Transformationsfunktion für jedes Element einer Sequenz auf und gibt den minimalen Int32 Wert zurück. |
Min<TSource>(IEnumerable<TSource>, Func<TSource,Int64>) |
Ruft eine Transformationsfunktion für jedes Element einer Sequenz auf und gibt den minimalen Int64 Wert zurück. |
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>) |
Ruft eine Transformationsfunktion für jedes Element einer Sequenz auf und gibt den minimal nullfähigen Decimal Wert zurück. |
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>) |
Ruft eine Transformationsfunktion für jedes Element einer Sequenz auf und gibt den minimal nullfähigen Double Wert zurück. |
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>) |
Ruft eine Transformationsfunktion für jedes Element einer Sequenz auf und gibt den minimal nullfähigen Int32 Wert zurück. |
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>) |
Ruft eine Transformationsfunktion für jedes Element einer Sequenz auf und gibt den minimal nullfähigen Int64 Wert zurück. |
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>) |
Ruft eine Transformationsfunktion für jedes Element einer Sequenz auf und gibt den minimal nullfähigen Single Wert zurück. |
Min<TSource>(IEnumerable<TSource>, Func<TSource,Single>) |
Ruft eine Transformationsfunktion für jedes Element einer Sequenz auf und gibt den minimalen Single Wert zurück. |
Min<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>) |
Ruft eine Transformationsfunktion für jedes Element einer generischen Sequenz auf und gibt den minimalen resultierenden Wert zurück. |
MinBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) |
Gibt den Minimalwert in einer generischen Sequenz gemäß einer angegebenen Schlüsselmarkierfunktion zurück. |
MinBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>) |
Gibt den Minimalwert in einer generischen Sequenz gemäß einer angegebenen Schlüsselauswahlfunktion und einem Schlüsselabgleich zurück. |
OfType<TResult>(IEnumerable) |
Filtert die Elemente einer IEnumerable basierend auf einem angegebenen Typ. |
Order<T>(IEnumerable<T>) |
Sortiert die Elemente einer Sequenz in aufsteigender Reihenfolge. |
Order<T>(IEnumerable<T>, IComparer<T>) |
Sortiert die Elemente einer Sequenz in aufsteigender Reihenfolge. |
OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) |
Sortiert die Elemente einer Sequenz in aufsteigender Reihenfolge nach einem Schlüssel. |
OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>) |
Sortiert die Elemente einer Sequenz in aufsteigender Reihenfolge mithilfe eines angegebenen Vergleichs. |
OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) |
Sortiert die Elemente einer Sequenz in absteigender Reihenfolge nach einem Schlüssel. |
OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>) |
Sortiert die Elemente einer Sequenz in absteigender Reihenfolge mithilfe eines angegebenen Vergleichs. |
OrderDescending<T>(IEnumerable<T>) |
Sortiert die Elemente einer Sequenz in absteigender Reihenfolge. |
OrderDescending<T>(IEnumerable<T>, IComparer<T>) |
Sortiert die Elemente einer Sequenz in absteigender Reihenfolge. |
Prepend<TSource>(IEnumerable<TSource>, TSource) |
Fügt am Anfang der Sequenz einen Wert hinzu. |
Reverse<TSource>(IEnumerable<TSource>) |
Invertiert die Reihenfolge der Elemente in einer Sequenz. |
Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>) |
Projiziert jedes Element einer Sequenz in ein neues Formular. |
Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,TResult>) |
Projiziert jedes Element einer Sequenz in ein neues Formular, indem er den Index des Elements einbezieht. |
SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>) |
Projiziert jedes Element einer Sequenz auf eine IEnumerable<T> und vereinfacht die resultierenden Sequenzen in eine Sequenz. |
SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>) |
Projiziert jedes Element einer Sequenz auf eine IEnumerable<T>und schmeichelt die resultierenden Sequenzen in einer Sequenz ab. Der Index der einzelnen Quellelemente wird in der projizierten Form dieses Elements verwendet. |
SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) |
Projiziert jedes Element einer Sequenz auf eine IEnumerable<T>, schmeichelt die resultierenden Sequenzen in eine Sequenz und ruft eine Ergebnismarkierfunktion für jedes element darin auf. |
SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) |
Projiziert jedes Element einer Sequenz auf eine IEnumerable<T>, schmeichelt die resultierenden Sequenzen in eine Sequenz und ruft eine Ergebnismarkierfunktion für jedes element darin auf. Der Index der einzelnen Quellelemente wird in der zwischen projizierten Form dieses Elements verwendet. |
SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) |
Bestimmt, ob zwei Sequenzen gleich sind, indem die Elemente mithilfe des Standardmäßigen Gleichheitsabgleichs für ihren Typ verglichen werden. |
SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>) |
Bestimmt, ob zwei Sequenzen gleich sind, indem sie ihre Elemente mithilfe einer angegebenen IEqualityComparer<T>vergleichen. |
Single<TSource>(IEnumerable<TSource>) |
Gibt das einzige Element einer Sequenz zurück und löst eine Ausnahme aus, wenn nicht genau ein Element in der Sequenz vorhanden ist. |
Single<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Gibt das einzige Element einer Sequenz zurück, das eine angegebene Bedingung erfüllt, und löst eine Ausnahme aus, wenn mehr als ein solches Element vorhanden ist. |
SingleOrDefault<TSource>(IEnumerable<TSource>) |
Gibt das einzige Element einer Sequenz oder einen Standardwert zurück, wenn die Sequenz leer ist; Diese Methode löst eine Ausnahme aus, wenn mehrere Elemente in der Sequenz vorhanden sind. |
SingleOrDefault<TSource>(IEnumerable<TSource>, TSource) |
Gibt das einzige Element einer Sequenz oder einen angegebenen Standardwert zurück, wenn die Sequenz leer ist; Diese Methode löst eine Ausnahme aus, wenn mehrere Elemente in der Sequenz vorhanden sind. |
SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Gibt das einzige Element einer Sequenz zurück, das eine angegebene Bedingung oder einen Standardwert erfüllt, wenn kein solches Element vorhanden ist; Diese Methode löst eine Ausnahme aus, wenn mehrere Elemente die Bedingung erfüllen. |
SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource) |
Gibt das einzige Element einer Sequenz zurück, das eine angegebene Bedingung erfüllt, oder einen angegebenen Standardwert, wenn kein solches Element vorhanden ist; Diese Methode löst eine Ausnahme aus, wenn mehrere Elemente die Bedingung erfüllen. |
Skip<TSource>(IEnumerable<TSource>, Int32) |
Umgeht eine angegebene Anzahl von Elementen in einer Sequenz und gibt dann die verbleibenden Elemente zurück. |
SkipLast<TSource>(IEnumerable<TSource>, Int32) |
Gibt eine neue aufzählbare Auflistung zurück, die die Elemente aus |
SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Umgeht Elemente in einer Sequenz, solange eine angegebene Bedingung wahr ist, und gibt dann die verbleibenden Elemente zurück. |
SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>) |
Umgeht Elemente in einer Sequenz, solange eine angegebene Bedingung wahr ist, und gibt dann die verbleibenden Elemente zurück. Der Index des Elements wird in der Logik der Prädikatfunktion verwendet. |
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>) |
Berechnet die Summe der Sequenz von Decimal Werten, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden. |
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) |
Berechnet die Summe der Sequenz von Double Werten, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden. |
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int32>) |
Berechnet die Summe der Sequenz von Int32 Werten, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden. |
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int64>) |
Berechnet die Summe der Sequenz von Int64 Werten, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden. |
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>) |
Berechnet die Summe der Sequenz von nullablen Decimal Werten, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden. |
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>) |
Berechnet die Summe der Sequenz von nullablen Double Werten, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden. |
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>) |
Berechnet die Summe der Sequenz von nullablen Int32 Werten, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden. |
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>) |
Berechnet die Summe der Sequenz von nullablen Int64 Werten, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden. |
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>) |
Berechnet die Summe der Sequenz von nullablen Single Werten, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden. |
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Single>) |
Berechnet die Summe der Sequenz von Single Werten, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden. |
Take<TSource>(IEnumerable<TSource>, Int32) |
Gibt eine angegebene Anzahl zusammenhängender Elemente vom Anfang einer Sequenz zurück. |
Take<TSource>(IEnumerable<TSource>, Range) |
Gibt einen angegebenen Bereich zusammenhängender Elemente aus einer Sequenz zurück. |
TakeLast<TSource>(IEnumerable<TSource>, Int32) |
Gibt eine neue enumerationsfähige Auflistung zurück, die die letzten |
TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Gibt Elemente aus einer Sequenz zurück, solange eine angegebene Bedingung wahr ist. |
TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>) |
Gibt Elemente aus einer Sequenz zurück, solange eine angegebene Bedingung wahr ist. Der Index des Elements wird in der Logik der Prädikatfunktion verwendet. |
ToArray<TSource>(IEnumerable<TSource>) |
Erstellt ein Array aus einem IEnumerable<T>. |
ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) |
Erstellt eine Dictionary<TKey,TValue> aus einer IEnumerable<T> gemäß einer angegebenen Schlüsselauswahlfunktion. |
ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) |
Erstellt eine Dictionary<TKey,TValue> aus einer IEnumerable<T> gemäß einer angegebenen Schlüsselauswahlfunktion und einem Schlüsselvergleich. |
ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>) |
Erstellt eine Dictionary<TKey,TValue> aus einer IEnumerable<T> gemäß den angegebenen Schlüsselauswahl- und Elementauswahlfunktionen. |
ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>) |
Erstellt eine Dictionary<TKey,TValue> aus einer IEnumerable<T> gemäß einer angegebenen Schlüsselauswahlfunktion, einem Vergleichsmodul und einer Elementauswahlfunktion. |
ToHashSet<TSource>(IEnumerable<TSource>) |
Erstellt eine HashSet<T> aus einem IEnumerable<T>. |
ToHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>) |
Erstellt mithilfe des |
ToList<TSource>(IEnumerable<TSource>) |
Erstellt eine List<T> aus einem IEnumerable<T>. |
ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) |
Erstellt eine Lookup<TKey,TElement> aus einer IEnumerable<T> gemäß einer angegebenen Schlüsselauswahlfunktion. |
ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) |
Erstellt eine Lookup<TKey,TElement> aus einer IEnumerable<T> gemäß einer angegebenen Schlüsselauswahlfunktion und einem Schlüsselvergleich. |
ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>) |
Erstellt eine Lookup<TKey,TElement> aus einer IEnumerable<T> gemäß den angegebenen Schlüsselauswahl- und Elementauswahlfunktionen. |
ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>) |
Erstellt eine Lookup<TKey,TElement> aus einer IEnumerable<T> gemäß einer angegebenen Schlüsselauswahlfunktion, einem Vergleichsmodul und einer Elementauswahlfunktion. |
TryGetNonEnumeratedCount<TSource>(IEnumerable<TSource>, Int32) |
Versucht, die Anzahl der Elemente in einer Sequenz zu ermitteln, ohne eine Enumeration zu erzwingen. |
Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) |
Erzeugt die Festgelegte Vereinigung von zwei Sequenzen mithilfe des Standardgleichstellungsabgleichs. |
Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>) |
Erzeugt die Set-Vereinigung von zwei Sequenzen mithilfe eines angegebenen IEqualityComparer<T>. |
UnionBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TSource>, Func<TSource,TKey>) |
Erzeugt die Set-Vereinigung von zwei Sequenzen gemäß einer angegebenen Schlüsselmarkierfunktion. |
UnionBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) |
Erzeugt die Set-Vereinigung von zwei Sequenzen gemäß einer angegebenen Schlüsselmarkierfunktion. |
Where<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Filtert eine Abfolge von Werten basierend auf einem Prädikat. |
Where<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>) |
Filtert eine Abfolge von Werten basierend auf einem Prädikat. Der Index jedes Elements wird in der Logik der Prädikatfunktion verwendet. |
Zip<TFirst,TSecond>(IEnumerable<TFirst>, IEnumerable<TSecond>) |
Erzeugt eine Abfolge von Tupeln mit Elementen aus den beiden angegebenen Sequenzen. |
Zip<TFirst,TSecond,TThird>(IEnumerable<TFirst>, IEnumerable<TSecond>, IEnumerable<TThird>) |
Erzeugt eine Abfolge von Tupeln mit Elementen aus den drei angegebenen Sequenzen. |
Zip<TFirst,TSecond,TResult>(IEnumerable<TFirst>, IEnumerable<TSecond>, Func<TFirst,TSecond,TResult>) |
Wendet eine angegebene Funktion auf die entsprechenden Elemente von zwei Sequenzen an, wodurch eine Folge der Ergebnisse erzeugt wird. |
AsParallel(IEnumerable) |
Aktiviert die Parallelisierung einer Abfrage. |
AsParallel<TSource>(IEnumerable<TSource>) |
Aktiviert die Parallelisierung einer Abfrage. |
AsQueryable(IEnumerable) |
Wandelt eine IEnumerable in eine IQueryableum. |
AsQueryable<TElement>(IEnumerable<TElement>) |
Wandelt eine generische IEnumerable<T> in eine generische IQueryable<T>um. |
Ancestors<T>(IEnumerable<T>) |
Gibt eine Auflistung von Elementen zurück, die die Vorgänger aller Knoten in der Quellauflistung enthalten. |
Ancestors<T>(IEnumerable<T>, XName) |
Gibt eine gefilterte Auflistung von Elementen zurück, die die Vorgänger aller Knoten in der Quellauflistung enthalten. In der Auflistung sind nur Elemente enthalten, die über einen übereinstimmenden XName verfügen. |
DescendantNodes<T>(IEnumerable<T>) |
Gibt eine Auflistung der untergeordneten Knoten jedes Dokuments und Elements in der Quellauflistung zurück. |
Descendants<T>(IEnumerable<T>) |
Gibt eine Auflistung von Elementen zurück, die die untergeordneten Elemente jedes Elements und Dokuments in der Quellauflistung enthalten. |
Descendants<T>(IEnumerable<T>, XName) |
Gibt eine gefilterte Auflistung von Elementen zurück, die die untergeordneten Elemente jedes Elements und Dokuments in der Quellauflistung enthalten. In der Auflistung sind nur Elemente enthalten, die über einen übereinstimmenden XName verfügen. |
Elements<T>(IEnumerable<T>) |
Gibt eine Auflistung der untergeordneten Elemente jedes Elements und Dokuments in der Quellauflistung zurück. |
Elements<T>(IEnumerable<T>, XName) |
Gibt eine gefilterte Auflistung der untergeordneten Elemente jedes Elements und Dokuments in der Quellauflistung zurück. In der Auflistung sind nur Elemente enthalten, die über einen übereinstimmenden XName verfügen. |
InDocumentOrder<T>(IEnumerable<T>) |
Gibt eine Auflistung von Knoten zurück, die alle Knoten in der Quellauflistung enthält, sortiert in der Dokumentreihenfolge. |
Nodes<T>(IEnumerable<T>) |
Gibt eine Auflistung der untergeordneten Knoten jedes Dokuments und Elements in der Quellauflistung zurück. |
Remove<T>(IEnumerable<T>) |
Entfernt jeden Knoten in der Quellauflistung aus dem übergeordneten Knoten. |
Gilt für:
Threadsicherheit
Dieser Typ ist nicht threadsicher. Wenn auf die LinkedList<T> von mehreren Threads zugegriffen werden muss, müssen Sie Ihren eigenen Synchronisierungsmechanismus implementieren.
Ein LinkedList<T> kann mehrere Leser gleichzeitig unterstützen, solange die Sammlung nicht geändert wird. Das Aufzählen durch eine Sammlung ist in der Regel keine threadsichere Prozedur. In dem seltenen Fall, in dem eine Aufzählung schreibgeschützt ist, muss die Auflistung während der gesamten Aufzählung gesperrt werden. Damit auf die Sammlung über mehrere Threads zum Lesen und Schreiben zugegriffen werden kann, müssen Sie eine eigene Synchronisierung implementieren.
Weitere Informationen
Feedback
https://aka.ms/ContentUserFeedback.
Bald verfügbar: Im Laufe des Jahres 2024 werden wir GitHub-Issues stufenweise als Feedbackmechanismus für Inhalte abbauen und durch ein neues Feedbacksystem ersetzen. Weitere Informationen finden Sie unterFeedback senden und anzeigen für