ConcurrentDictionary<TKey,TValue> Klass

Definition

Namnområde:: System.Collections.Concurrent

Sammansättningar:: mscorlib.dll, System.Collections.Concurrent.dll

Sammansättning:: mscorlib.dll

Sammansättning:: System.Collections.Concurrent.dll

Sammansättning:: netstandard.dll

Viktigt

En del information gäller för förhandsversionen av en produkt och kan komma att ändras avsevärt innan produkten blir allmänt tillgänglig. Microsoft lämnar inga garantier, uttryckliga eller underförstådda, avseende informationen som visas här.

Representerar en trådsäker samling nyckel/värde-par som kan nås av flera trådar samtidigt.

generic <typename TKey, typename TValue>
public ref class ConcurrentDictionary : System::Collections::Generic::ICollection<System::Collections::Generic::KeyValuePair<TKey, TValue>>, System::Collections::Generic::IDictionary<TKey, TValue>, System::Collections::Generic::IEnumerable<System::Collections::Generic::KeyValuePair<TKey, TValue>>, System::Collections::Generic::IReadOnlyCollection<System::Collections::Generic::KeyValuePair<TKey, TValue>>, System::Collections::Generic::IReadOnlyDictionary<TKey, TValue>, System::Collections::IDictionary

generic <typename TKey, typename TValue>
public ref class ConcurrentDictionary : System::Collections::Generic::ICollection<System::Collections::Generic::KeyValuePair<TKey, TValue>>, System::Collections::Generic::IDictionary<TKey, TValue>, System::Collections::Generic::IEnumerable<System::Collections::Generic::KeyValuePair<TKey, TValue>>, System::Collections::IDictionary

public class ConcurrentDictionary<TKey,TValue> : System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>, System.Collections.Generic.IDictionary<TKey,TValue>, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey,TValue>>, System.Collections.Generic.IReadOnlyCollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>, System.Collections.Generic.IReadOnlyDictionary<TKey,TValue>, System.Collections.IDictionary

[System.Runtime.InteropServices.ComVisible(false)]
[System.Serializable]
public class ConcurrentDictionary<TKey,TValue> : System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>, System.Collections.Generic.IDictionary<TKey,TValue>, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey,TValue>>, System.Collections.IDictionary

[System.Runtime.InteropServices.ComVisible(false)]
[System.Serializable]
public class ConcurrentDictionary<TKey,TValue> : System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>, System.Collections.Generic.IDictionary<TKey,TValue>, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey,TValue>>, System.Collections.Generic.IReadOnlyCollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>, System.Collections.Generic.IReadOnlyDictionary<TKey,TValue>, System.Collections.IDictionary

public class ConcurrentDictionary<TKey,TValue> : System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>, System.Collections.Generic.IDictionary<TKey,TValue>, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey,TValue>>, System.Collections.IDictionary

type ConcurrentDictionary<'Key, 'Value> = class
    interface ICollection<KeyValuePair<'Key, 'Value>>
    interface seq<KeyValuePair<'Key, 'Value>>
    interface IEnumerable
    interface IDictionary<'Key, 'Value>
    interface IReadOnlyCollection<KeyValuePair<'Key, 'Value>>
    interface IReadOnlyDictionary<'Key, 'Value>
    interface ICollection
    interface IDictionary

[<System.Runtime.InteropServices.ComVisible(false)>]
[<System.Serializable>]
type ConcurrentDictionary<'Key, 'Value> = class
    interface IDictionary<'Key, 'Value>
    interface ICollection<KeyValuePair<'Key, 'Value>>
    interface seq<KeyValuePair<'Key, 'Value>>
    interface IDictionary
    interface ICollection
    interface IEnumerable

[<System.Runtime.InteropServices.ComVisible(false)>]
[<System.Serializable>]
type ConcurrentDictionary<'Key, 'Value> = class
    interface IDictionary<'Key, 'Value>
    interface ICollection<KeyValuePair<'Key, 'Value>>
    interface seq<KeyValuePair<'Key, 'Value>>
    interface IEnumerable
    interface IDictionary
    interface ICollection
    interface IReadOnlyDictionary<'Key, 'Value>
    interface IReadOnlyCollection<KeyValuePair<'Key, 'Value>>

type ConcurrentDictionary<'Key, 'Value> = class
    interface IDictionary<'Key, 'Value>
    interface ICollection<KeyValuePair<'Key, 'Value>>
    interface seq<KeyValuePair<'Key, 'Value>>
    interface IDictionary
    interface ICollection
    interface IEnumerable

Public Class ConcurrentDictionary(Of TKey, TValue)
Implements ICollection(Of KeyValuePair(Of TKey, TValue)), IDictionary, IDictionary(Of TKey, TValue), IEnumerable(Of KeyValuePair(Of TKey, TValue)), IReadOnlyCollection(Of KeyValuePair(Of TKey, TValue)), IReadOnlyDictionary(Of TKey, TValue)

Public Class ConcurrentDictionary(Of TKey, TValue)
Implements ICollection(Of KeyValuePair(Of TKey, TValue)), IDictionary, IDictionary(Of TKey, TValue), IEnumerable(Of KeyValuePair(Of TKey, TValue))

Typparametrar

TKey

Typ av nycklar i ordlistan.

TValue

Typ av värden i ordlistan.

Arv: Object
ConcurrentDictionary<TKey,TValue>

Attribut: ComVisibleAttribute SerializableAttribute

Implementeringar: ICollection<KeyValuePair<TKey,TValue>> IDictionary<TKey,TValue> IEnumerable<KeyValuePair<TKey,TValue>> IEnumerable<T> IReadOnlyCollection<KeyValuePair<TKey,TValue>> IReadOnlyDictionary<TKey,TValue> ICollection IDictionary IEnumerable

Exempel

I följande exempel visas hur du konstruerar ett ConcurrentDictionary<TKey,TValue> objekt.


class CD_Ctor
{
        // Demonstrates:
        //      ConcurrentDictionary<TKey, TValue> ctor(concurrencyLevel, initialCapacity)
        //      ConcurrentDictionary<TKey, TValue>[TKey]
        static void Main()
        {
            // We know how many items we want to insert into the ConcurrentDictionary.
            // So set the initial capacity to some prime number above that, to ensure that
            // the ConcurrentDictionary does not need to be resized while initializing it.
            int NUMITEMS = 64;
            int initialCapacity = 101;

            // The higher the concurrencyLevel, the higher the theoretical number of operations
            // that could be performed concurrently on the ConcurrentDictionary.  However, global
            // operations like resizing the dictionary take longer as the concurrencyLevel rises.
            // For the purposes of this example, we'll compromise at numCores * 2.
            int numProcs = Environment.ProcessorCount;
            int concurrencyLevel = numProcs * 2;

            // Construct the dictionary with the desired concurrencyLevel and initialCapacity
            ConcurrentDictionary<int, int> cd = new ConcurrentDictionary<int, int>(concurrencyLevel, initialCapacity);

            // Initialize the dictionary
            for (int i = 0; i < NUMITEMS; i++) cd[i] = i * i;

            Console.WriteLine("The square of 23 is {0} (should be {1})", cd[23], 23 * 23);
        }
}

// Demonstrates:
//      ConcurrentDictionary<TKey, TValue> ctor(concurrencyLevel, initialCapacity)
//      ConcurrentDictionary<TKey, TValue>[TKey]

// We know how many items we want to insert into the ConcurrentDictionary.
// So set the initial capacity to some prime number above that, to ensure that
// the ConcurrentDictionary does not need to be resized while initializing it.
let NUMITEMS = 64
let initialCapacity = 101

// The higher the concurrencyLevel, the higher the theoretical number of operations
// that could be performed concurrently on the ConcurrentDictionary.  However, global
// operations like resizing the dictionary take longer as the concurrencyLevel rises.
// For the purposes of this example, we'll compromise at numCores * 2.
let numProcs = Environment.ProcessorCount
let concurrencyLevel = numProcs * 2

// Construct the dictionary with the desired concurrencyLevel and initialCapacity
let cd = ConcurrentDictionary<int, int>(concurrencyLevel, initialCapacity)

// Initialize the dictionary
for i = 0 to NUMITEMS - 1 do
    cd[i] <- i * i

printfn $"The square of 23 is {cd[23]} (should be {23 * 23})"

Imports System.Collections.Concurrent
Imports System.Threading.Tasks

Class CD_Ctor
    ' Demonstrates:
    ' ConcurrentDictionary<TKey, TValue> ctor(concurrencyLevel, initialCapacity)
    ' ConcurrentDictionary<TKey, TValue>[TKey]
    Shared Sub Main()
        ' We know how many items we want to insert into the ConcurrentDictionary.
        ' So set the initial capacity to some prime number above that, to ensure that
        ' the ConcurrentDictionary does not need to be resized while initializing it.
        Dim NUMITEMS As Integer = 64
        Dim initialCapacity As Integer = 101

        ' The higher the concurrencyLevel, the higher the theoretical number of operations
        ' that could be performed concurrently on the ConcurrentDictionary. However, global
        ' operations like resizing the dictionary take longer as the concurrencyLevel rises. 
        ' For the purposes of this example, we'll compromise at numCores * 2.
        Dim numProcs As Integer = Environment.ProcessorCount
        Dim concurrencyLevel As Integer = numProcs * 2

        ' Construct the dictionary with the desired concurrencyLevel and initialCapacity
        Dim cd As New ConcurrentDictionary(Of Integer, Integer)(concurrencyLevel, initialCapacity)

        ' Initialize the dictionary
        For i As Integer = 0 To NUMITEMS - 1
            cd(i) = i * i
        Next

        Console.WriteLine("The square of 23 is {0} (should be {1})", cd(23), 23 * 23)
    End Sub
End Class

Kommentarer

För mycket stora ConcurrentDictionary<TKey,TValue> objekt kan du öka den maximala matrisstorleken till 2 gigabyte (GB) i ett 64-bitarssystem genom att ange <gcAllowVeryLargeObjects> konfigurationselementet till true i körningsmiljön.

Note

ConcurrentDictionary<TKey,TValue> implementerar gränssnitten IReadOnlyCollection<T> och IReadOnlyDictionary<TKey,TValue> från och med .NET Framework 4.6. I tidigare versioner av .NET Framework implementerade inte klassen ConcurrentDictionary<TKey,TValue> dessa gränssnitt.

Precis som System.Collections.Generic.Dictionary<TKey,TValue> klassen ConcurrentDictionary<TKey,TValue> implementerar gränssnittet IDictionary<TKey,TValue> . Dessutom ConcurrentDictionary<TKey,TValue> finns flera metoder för att lägga till eller uppdatera nyckel/värde-par i ordlistan enligt beskrivningen i följande tabell.

Om du vill	Använd den här metoden	Användningsanteckningar
Lägg till en ny nyckel i ordlistan om den inte redan finns i ordlistan	TryAdd	Den här metoden lägger till det angivna nyckel/värde-paret om nyckeln för närvarande inte finns i ordlistan. Metoden returnerar `true` eller `false` beroende på om det nya paret har lagts till.
Uppdatera värdet för en befintlig nyckel i ordlistan om nyckeln har ett specifikt värde	TryUpdate	Den här metoden kontrollerar om nyckeln har ett angivet värde, och om den gör det uppdateras nyckeln med ett nytt värde. Den liknar metoden, förutom att den CompareExchange används för ordlisteelement.
Lagra ett nyckel/värde-par i ordlistan villkorslöst och skriv över värdet för en nyckel som redan finns	Indexerarens setter: `dictionary[key] = newValue`
Lägg till ett nyckel/värde-par i ordlistan, eller om nyckeln redan finns uppdaterar du värdet för nyckeln baserat på nyckelns befintliga värde	AddOrUpdate(TKey, Func<TKey,TValue>, Func<TKey,TValue,TValue>) -eller- AddOrUpdate(TKey, TValue, Func<TKey,TValue,TValue>)	AddOrUpdate(TKey, Func<TKey,TValue>, Func<TKey,TValue,TValue>) accepterar nyckeln och två ombud. Den använder det första ombudet om nyckeln inte finns i ordlistan. den accepterar nyckeln och returnerar det värde som ska läggas till för nyckeln. Den använder det andra ombudet om nyckeln finns. den accepterar nyckeln och dess aktuella värde och returnerar det nya värde som ska anges för nyckeln. AddOrUpdate(TKey, TValue, Func<TKey,TValue,TValue>) accepterar nyckeln, ett värde att lägga till och uppdateringsdelegaten. Detta är samma som den tidigare överlagringen, förutom att den inte använder ett ombud för att lägga till en nyckel.
Hämta värdet för en nyckel i ordlistan, lägg till värdet i ordlistan och returnera det om nyckeln inte finns	GetOrAdd(TKey, TValue) -eller- GetOrAdd(TKey, Func<TKey,TValue>)	Dessa överlagringar ger en lat initiering för ett nyckel/värde-par i ordlistan och lägger bara till värdet om det inte finns där. GetOrAdd(TKey, TValue) tar värdet som ska läggas till om nyckeln inte finns. GetOrAdd(TKey, Func<TKey,TValue>) tar ett ombud som genererar värdet om nyckeln inte finns.

Alla dessa åtgärder är atomiska och trådsäkra när det gäller alla andra åtgärder i ConcurrentDictionary<TKey,TValue> klassen. De enda undantagen är de metoder som accepterar ett ombud, dvs AddOrUpdate . och GetOrAdd. För ändringar och skrivåtgärder i ordlistan ConcurrentDictionary<TKey,TValue> använder finkornig låsning för att säkerställa trådsäkerheten. (Läsåtgärder i ordlistan utförs på ett låsfritt sätt.) Ombud för dessa metoder anropas dock utanför låsen för att undvika de problem som kan uppstå vid körning av okänd kod under ett lås. Därför omfattas inte koden som körs av dessa ombud av åtgärdens atomitet.

Konstruktorer

Name	Description
ConcurrentDictionary<TKey,TValue>()	Initierar en ny instans av ConcurrentDictionary<TKey,TValue> klassen som är tom, har standardnivån samtidighet, har standardinitieringskapaciteten och använder standardjämeraren för nyckeltypen.
ConcurrentDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>, IEqualityComparer<TKey>)	Initierar en ny instans av ConcurrentDictionary<TKey,TValue> klassen som innehåller element som kopierats från den angivna IEnumerable har standardkonkurrencynivån, har standardinitieringskapaciteten och använder den angivna IEqualityComparer<T>.
ConcurrentDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>)	Initierar en ny instans av ConcurrentDictionary<TKey,TValue> klassen som innehåller element som kopierats från den angivna IEnumerable<T>, har standardkonkurrencynivån, har standardinitieringskapaciteten och använder standardjäxaren för nyckeltypen.
ConcurrentDictionary<TKey,TValue>(IEqualityComparer<TKey>)	Initierar en ny instans av ConcurrentDictionary<TKey,TValue> klassen som är tom, har standardnivån för samtidighet och kapacitet och använder den angivna IEqualityComparer<T>.
ConcurrentDictionary<TKey,TValue>(Int32, IEnumerable<KeyValuePair<TKey,TValue>>, IEqualityComparer<TKey>)	Initierar en ny instans av ConcurrentDictionary<TKey,TValue> klassen som innehåller element som kopierats från den angivna IEnumerableoch använder den angivna IEqualityComparer<T>.
ConcurrentDictionary<TKey,TValue>(Int32, Int32, IEqualityComparer<TKey>)	Initierar en ny instans av ConcurrentDictionary<TKey,TValue> klassen som är tom, har den angivna samtidighetsnivån, har den angivna initiala kapaciteten och använder den angivna IEqualityComparer<T>.
ConcurrentDictionary<TKey,TValue>(Int32, Int32)	Initierar en ny instans av ConcurrentDictionary<TKey,TValue> klassen som är tom, har den angivna samtidighetsnivån och kapaciteten och använder standardjämeraren för nyckeltypen.

Egenskaper

Name	Description
Count	Hämtar antalet nyckel/värde-par som finns i ConcurrentDictionary<TKey,TValue>.
IsEmpty	Hämtar ett värde som anger om är ConcurrentDictionary<TKey,TValue> tomt.
Item[TKey]	Hämtar eller anger värdet som är associerat med den angivna nyckeln.
Keys	Hämtar en samling som innehåller nycklarna i Dictionary<TKey,TValue>.
Values	Hämtar en samling som innehåller värdena i Dictionary<TKey,TValue>.

Metoder

Name	Description
AddOrUpdate(TKey, Func<TKey,TValue>, Func<TKey,TValue,TValue>)	Använder de angivna funktionerna för att lägga till ett nyckel/värde-par i ConcurrentDictionary<TKey,TValue> om nyckeln inte redan finns, eller för att uppdatera ett nyckel/värde-par i ConcurrentDictionary<TKey,TValue> om nyckeln redan finns.
AddOrUpdate(TKey, TValue, Func<TKey,TValue,TValue>)	Lägger till ett nyckel/värde-par i ConcurrentDictionary<TKey,TValue> om nyckeln inte redan finns, eller uppdaterar ett nyckel/värde-par i ConcurrentDictionary<TKey,TValue> med hjälp av den angivna funktionen om nyckeln redan finns.
AddOrUpdate<TArg>(TKey, Func<TKey,TArg,TValue>, Func<TKey,TValue,TArg,TValue>, TArg)	Använder de angivna funktionerna och argumentet för att lägga till ett nyckel/värde-par i ConcurrentDictionary<TKey,TValue> om nyckeln inte redan finns, eller för att uppdatera ett nyckel/värde-par i ConcurrentDictionary<TKey,TValue> om nyckeln redan finns.
Clear()	Tar bort alla nycklar och värden från ConcurrentDictionary<TKey,TValue>.
ContainsKey(TKey)	Avgör om innehåller den ConcurrentDictionary<TKey,TValue> angivna nyckeln.
Equals(Object)	Avgör om det angivna objektet är lika med det aktuella objektet. (Ärvd från Object)
GetEnumerator()	Returnerar en uppräkning som itererar genom ConcurrentDictionary<TKey,TValue>.
GetHashCode()	Fungerar som standard-hash-funktion. (Ärvd från Object)
GetOrAdd(TKey, Func<TKey,TValue>)	Lägger till ett nyckel/värde-par i ConcurrentDictionary<TKey,TValue> med hjälp av den angivna funktionen om nyckeln inte redan finns. Returnerar det nya värdet eller det befintliga värdet om nyckeln finns.
GetOrAdd(TKey, TValue)	Lägger till ett nyckel/värde-par till ConcurrentDictionary<TKey,TValue> om nyckeln inte redan finns. Returnerar det nya värdet eller det befintliga värdet om nyckeln finns.
GetOrAdd<TArg>(TKey, Func<TKey,TArg,TValue>, TArg)	Lägger till ett nyckel/värde-par i ConcurrentDictionary<TKey,TValue> med hjälp av den angivna funktionen och ett argument om nyckeln inte redan finns, eller returnerar det befintliga värdet om nyckeln finns.
GetType()	Hämtar den aktuella instansen Type . (Ärvd från Object)
MemberwiseClone()	Skapar en ytlig kopia av den aktuella Object. (Ärvd från Object)
ToArray()	Kopierar nyckel- och värdeparen ConcurrentDictionary<TKey,TValue> som lagras i till en ny matris.
ToString()	Returnerar en sträng som representerar det aktuella objektet. (Ärvd från Object)
TryAdd(TKey, TValue)	Försöker lägga till den angivna nyckeln och värdet i ConcurrentDictionary<TKey,TValue>.
TryGetValue(TKey, TValue)	Försöker hämta värdet som är associerat med den angivna nyckeln från ConcurrentDictionary<TKey,TValue>.
TryRemove(TKey, TValue)	Försöker ta bort och returnera värdet som har den angivna nyckeln från ConcurrentDictionary<TKey,TValue>.
TryUpdate(TKey, TValue, TValue)	Uppdaterar värdet som är associerat med `key` om `newValue` det befintliga värdet med är lika `comparisonValue`med `key` .

Explicita gränssnittsimplementeringar

Name	Description
ICollection.CopyTo(Array, Int32)	Kopierar elementen i ICollection till en matris med början vid det angivna matrisindexet.
ICollection.IsSynchronized	Hämtar ett värde som anger om åtkomsten ICollection till synkroniseras med SyncRoot.
ICollection.SyncRoot	Hämtar ett objekt som kan användas för att synkronisera åtkomsten ICollectiontill . Den här egenskapen stöds inte.
ICollection<KeyValuePair<TKey,TValue>>.Add(KeyValuePair<TKey,TValue>)	Lägger till ett objekt i samlingen.
ICollection<KeyValuePair<TKey,TValue>>.Contains(KeyValuePair<TKey,TValue>)	Hämtar om innehåller ICollection<T> ett element med den angivna nyckeln.
ICollection<KeyValuePair<TKey,TValue>>.CopyTo(KeyValuePair<TKey,TValue>[], Int32)	Kopierar elementen i ICollection till en matris med början vid det angivna matrisindexet.
ICollection<KeyValuePair<TKey,TValue>>.IsReadOnly	Hämtar ett värde som anger om är ICollection skrivskyddat.
ICollection<KeyValuePair<TKey,TValue>>.Remove(KeyValuePair<TKey,TValue>)	Tar bort det angivna nyckel/värde-paret från samlingen.
IDictionary.Add(Object, Object)	Lägger till den angivna nyckeln och värdet i ordlistan.
IDictionary.Contains(Object)	Hämtar ett värde som anger IDictionary<TKey,TValue> att innehåller ett element med den angivna nyckeln.
IDictionary.GetEnumerator()	Tillhandahåller en IDictionaryEnumerator för IDictionary<TKey,TValue>.
IDictionary.IsFixedSize	Hämtar ett värde som anger om har IDictionary<TKey,TValue> en fast storlek.
IDictionary.IsReadOnly	Hämtar ett värde som anger om är IDictionary<TKey,TValue> skrivskyddat.
IDictionary.Item[Object]	Hämtar eller anger värdet som är associerat med den angivna nyckeln.
IDictionary.Keys	Hämtar en ICollection som innehåller nycklarna i IDictionary<TKey,TValue>.
IDictionary.Remove(Object)	Tar bort elementet med den angivna nyckeln från IDictionary.
IDictionary.Values	Hämtar en ICollection som innehåller värdena i IDictionary.
IDictionary<TKey,TValue>.Add(TKey, TValue)	Lägger till den angivna nyckeln och värdet i IDictionary<TKey,TValue>.
IDictionary<TKey,TValue>.Remove(TKey)	Tar bort elementet med den angivna nyckeln från IDictionary<TKey,TValue>.
IEnumerable.GetEnumerator()	Returnerar en uppräkning som itererar genom ConcurrentDictionary<TKey,TValue>.
IReadOnlyDictionary<TKey,TValue>.Keys	Hämtar en samling som innehåller nycklarna i Dictionary<TKey,TValue>.
IReadOnlyDictionary<TKey,TValue>.Values	Hämtar en samling som innehåller värdena i Dictionary<TKey,TValue>.

Tilläggsmetoder

Name	Description
Aggregate<TSource,TAccumulate,TResult>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>, Func<TAccumulate,TResult>)	Använder en ackumulatorfunktion över en sekvens. Det angivna startvärdet används som det initiala ackumulatorvärdet och den angivna funktionen används för att välja resultatvärdet.
Aggregate<TSource,TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>)	Använder en ackumulatorfunktion över en sekvens. Det angivna startvärdet används som det initiala ackumulatorvärdet.
Aggregate<TSource>(IEnumerable<TSource>, Func<TSource,TSource,TSource>)	Använder en ackumulatorfunktion över en sekvens.
All<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Avgör om alla element i en sekvens uppfyller ett villkor.
Ancestors<T>(IEnumerable<T>, XName)	Returnerar en filtrerad samling element som innehåller överordnade element för varje nod i källsamlingen. Endast element som har matchning XName ingår i samlingen.
Ancestors<T>(IEnumerable<T>)	Returnerar en samling element som innehåller överordnade element för varje nod i källsamlingen.
Any<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Avgör om något element i en sekvens uppfyller ett villkor.
Any<TSource>(IEnumerable<TSource>)	Avgör om en sekvens innehåller några element.
Append<TSource>(IEnumerable<TSource>, TSource)	Lägger till ett värde i slutet av sekvensen.
AsEnumerable<TSource>(IEnumerable<TSource>)	Returnerar indata som skrivits som IEnumerable<T>.
AsParallel(IEnumerable)	Möjliggör parallellisering av en fråga.
AsParallel<TSource>(IEnumerable<TSource>)	Möjliggör parallellisering av en fråga.
AsQueryable(IEnumerable)	Konverterar en IEnumerable till en IQueryable.
AsQueryable<TElement>(IEnumerable<TElement>)	Konverterar en allmän IEnumerable<T> till en allmän IQueryable<T>.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Beräknar medelvärdet av en sekvens med Decimal värden som erhålls genom att anropa en transformeringsfunktion på varje element i indatasekvensen.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Beräknar medelvärdet av en sekvens med Double värden som erhålls genom att anropa en transformeringsfunktion på varje element i indatasekvensen.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)	Beräknar medelvärdet av en sekvens med Int32 värden som erhålls genom att anropa en transformeringsfunktion på varje element i indatasekvensen.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)	Beräknar medelvärdet av en sekvens med Int64 värden som erhålls genom att anropa en transformeringsfunktion på varje element i indatasekvensen.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)	Beräknar medelvärdet av en sekvens med null-värden Decimal som erhålls genom att anropa en transformeringsfunktion på varje element i indatasekvensen.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)	Beräknar medelvärdet av en sekvens med null-värden Double som erhålls genom att anropa en transformeringsfunktion på varje element i indatasekvensen.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)	Beräknar medelvärdet av en sekvens med null-värden Int32 som erhålls genom att anropa en transformeringsfunktion på varje element i indatasekvensen.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)	Beräknar medelvärdet av en sekvens med null-värden Int64 som erhålls genom att anropa en transformeringsfunktion på varje element i indatasekvensen.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Beräknar medelvärdet av en sekvens med null-värden Single som erhålls genom att anropa en transformeringsfunktion på varje element i indatasekvensen.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Single>)	Beräknar medelvärdet av en sekvens med Single värden som erhålls genom att anropa en transformeringsfunktion på varje element i indatasekvensen.
Cast<TResult>(IEnumerable)	Omvandlar elementen i en IEnumerable till den angivna typen.
Concat<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Sammanfogar två sekvenser.
Contains<TSource>(IEnumerable<TSource>, TSource, IEqualityComparer<TSource>)	Avgör om en sekvens innehåller ett angivet element med hjälp av en angiven IEqualityComparer<T>.
Contains<TSource>(IEnumerable<TSource>, TSource)	Avgör om en sekvens innehåller ett angivet element med hjälp av standardjämförlikningsjämföraren.
CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler)	Kopierar DataRow objekt till angivet DataTable, givet ett indataobjekt IEnumerable<T> där den generiska parametern `T` är DataRow.
CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption)	Kopierar DataRow objekt till angivet DataTable, givet ett indataobjekt IEnumerable<T> där den generiska parametern `T` är DataRow.
CopyToDataTable<T>(IEnumerable<T>)	Returnerar en DataTable som innehåller kopior av objekten DataRow , givet ett indataobjekt IEnumerable<T> där den generiska parametern `T` är DataRow.
Count<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Returnerar ett tal som representerar hur många element i den angivna sekvensen som uppfyller ett villkor.
Count<TSource>(IEnumerable<TSource>)	Returnerar antalet element i en sekvens.
DefaultIfEmpty<TSource>(IEnumerable<TSource>, TSource)	Returnerar elementen i den angivna sekvensen eller det angivna värdet i en singleton-samling om sekvensen är tom.
DefaultIfEmpty<TSource>(IEnumerable<TSource>)	Returnerar elementen i den angivna sekvensen eller typparameterns standardvärde i en singleton-samling om sekvensen är tom.
DescendantNodes<T>(IEnumerable<T>)	Returnerar en samling underordnade noder i varje dokument och element i källsamlingen.
Descendants<T>(IEnumerable<T>, XName)	Returnerar en filtrerad samling element som innehåller underordnade element för varje element och dokument i källsamlingen. Endast element som har matchning XName ingår i samlingen.
Descendants<T>(IEnumerable<T>)	Returnerar en samling element som innehåller underordnade element för varje element och dokument i källsamlingen.
Distinct<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)	Returnerar distinkta element från en sekvens med hjälp av en angiven IEqualityComparer<T> för att jämföra värden.
Distinct<TSource>(IEnumerable<TSource>)	Returnerar distinkta element från en sekvens med hjälp av standardjämlikhetsjämföraren för att jämföra värden.
ElementAt<TSource>(IEnumerable<TSource>, Int32)	Returnerar elementet vid ett angivet index i en sekvens.
ElementAtOrDefault<TSource>(IEnumerable<TSource>, Int32)	Returnerar elementet vid ett angivet index i en sekvens eller ett standardvärde om indexet ligger utom intervallet.
Elements<T>(IEnumerable<T>, XName)	Returnerar en filtrerad samling av underordnade element i varje element och dokument i källsamlingen. Endast element som har matchning XName ingår i samlingen.
Elements<T>(IEnumerable<T>)	Returnerar en samling underordnade element i varje element och dokument i källsamlingen.
Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Skapar den inställda skillnaden mellan två sekvenser med hjälp av angivna IEqualityComparer<T> för att jämföra värden.
Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Ger den angivna skillnaden mellan två sekvenser genom att använda standardjämlikhetsjämförlikningsjämföraren för att jämföra värden.
First<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Returnerar det första elementet i en sekvens som uppfyller ett angivet villkor.
First<TSource>(IEnumerable<TSource>)	Returnerar det första elementet i en sekvens.
FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Returnerar det första elementet i sekvensen som uppfyller ett villkor eller ett standardvärde om inget sådant element hittas.
FirstOrDefault<TSource>(IEnumerable<TSource>)	Returnerar det första elementet i en sekvens eller ett standardvärde om sekvensen inte innehåller några element.
GetValueOrDefault<TKey,TValue>(IReadOnlyDictionary<TKey,TValue>, TKey, TValue)	Försöker hämta värdet som är associerat med det som anges `key` i `dictionary`.
GetValueOrDefault<TKey,TValue>(IReadOnlyDictionary<TKey,TValue>, TKey)	Försöker hämta värdet som är associerat med det som anges `key` i `dictionary`.
GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>, TResult>, IEqualityComparer<TKey>)	Grupperar elementen i en sekvens enligt en angiven nyckelväljare och skapar ett resultatvärde från varje grupp och dess nyckel. Nyckelvärden jämförs med en angiven jämförelse, och elementen i varje grupp projiceras med hjälp av en angiven funktion.
GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>)	Grupperar elementen i en sekvens enligt en angiven nyckelväljare och skapar ett resultatvärde från varje grupp och dess nyckel. Elementen i varje grupp projiceras med hjälp av en angiven funktion.
GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	Grupperar elementen i en sekvens enligt en nyckelväljare. Nycklarna jämförs med en jämförelse och varje grupps element projiceras med hjälp av en angiven funktion.
GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)	Grupperar elementen i en sekvens enligt en angiven nyckelväljare och projicerar elementen för varje grupp med hjälp av en angiven funktion.
GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>, IEqualityComparer<TKey>)	Grupperar elementen i en sekvens enligt en angiven nyckelväljare och skapar ett resultatvärde från varje grupp och dess nyckel. Nycklarna jämförs med en angiven jämförelse.
GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>)	Grupperar elementen i en sekvens enligt en angiven nyckelväljare och skapar ett resultatvärde från varje grupp och dess nyckel.
GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Grupperar elementen i en sekvens enligt en angiven nyckelväljare och jämför nycklarna med hjälp av en angiven jämförelse.
GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Grupperar elementen i en sekvens enligt en angiven nyckelväljare.
GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>, TResult>, IEqualityComparer<TKey>)	Korrelerar elementen i två sekvenser baserat på nyckeljämlikhet och grupperar resultaten. En angiven IEqualityComparer<T> används för att jämföra nycklar.
GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>, TResult>)	Korrelerar elementen i två sekvenser baserat på likhet mellan nycklar och grupperar resultatet. Standardjämförlikningsjämföraren används för att jämföra nycklar.
InDocumentOrder<T>(IEnumerable<T>)	Returnerar en samling noder som innehåller alla noder i källsamlingen, sorterade i dokumentordning.
Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Skapar den angivna skärningspunkten mellan två sekvenser med hjälp av angivna IEqualityComparer<T> för att jämföra värden.
Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Genererar den angivna skärningspunkten för två sekvenser med hjälp av standardjämlikhetsjämförlikningsjämföraren för att jämföra värden.
Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>, IEqualityComparer<TKey>)	Korrelerar elementen i två sekvenser baserat på matchande nycklar. En angiven IEqualityComparer<T> används för att jämföra nycklar.
Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>)	Korrelerar elementen i två sekvenser baserat på matchande nycklar. Standardjämförlikningsjämföraren används för att jämföra nycklar.
Last<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Returnerar det sista elementet i en sekvens som uppfyller ett angivet villkor.
Last<TSource>(IEnumerable<TSource>)	Returnerar det sista elementet i en sekvens.
LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Returnerar det sista elementet i en sekvens som uppfyller ett villkor eller ett standardvärde om inget sådant element hittas.
LastOrDefault<TSource>(IEnumerable<TSource>)	Returnerar det sista elementet i en sekvens eller ett standardvärde om sekvensen inte innehåller några element.
LongCount<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Returnerar ett Int64 som representerar hur många element i en sekvens som uppfyller ett villkor.
LongCount<TSource>(IEnumerable<TSource>)	Returnerar ett Int64 som representerar det totala antalet element i en sekvens.
Max<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)	Anropar en transformeringsfunktion på varje element i en allmän sekvens och returnerar det maximala resulterande värdet.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Anropar en transformeringsfunktion på varje element i en sekvens och returnerar det maximala Decimal värdet.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Anropar en transformeringsfunktion på varje element i en sekvens och returnerar det maximala Double värdet.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)	Anropar en transformeringsfunktion på varje element i en sekvens och returnerar det maximala Int32 värdet.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)	Anropar en transformeringsfunktion på varje element i en sekvens och returnerar det maximala Int64 värdet.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)	Anropar en transformeringsfunktion på varje element i en sekvens och returnerar det maximala null-värdet Decimal .
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)	Anropar en transformeringsfunktion på varje element i en sekvens och returnerar det maximala null-värdet Double .
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)	Anropar en transformeringsfunktion på varje element i en sekvens och returnerar det maximala null-värdet Int32 .
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)	Anropar en transformeringsfunktion på varje element i en sekvens och returnerar det maximala null-värdet Int64 .
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Anropar en transformeringsfunktion på varje element i en sekvens och returnerar det maximala null-värdet Single .
Max<TSource>(IEnumerable<TSource>, Func<TSource,Single>)	Anropar en transformeringsfunktion på varje element i en sekvens och returnerar det maximala Single värdet.
Max<TSource>(IEnumerable<TSource>)	Returnerar det maximala värdet i en allmän sekvens.
Min<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)	Anropar en transformeringsfunktion på varje element i en allmän sekvens och returnerar det lägsta resulterande värdet.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Anropar en transformeringsfunktion på varje element i en sekvens och returnerar minimivärdet Decimal .
Min<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Anropar en transformeringsfunktion på varje element i en sekvens och returnerar minimivärdet Double .
Min<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)	Anropar en transformeringsfunktion på varje element i en sekvens och returnerar minimivärdet Int32 .
Min<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)	Anropar en transformeringsfunktion på varje element i en sekvens och returnerar minimivärdet Int64 .
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)	Anropar en transformeringsfunktion på varje element i en sekvens och returnerar det lägsta null-värdet Decimal .
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)	Anropar en transformeringsfunktion på varje element i en sekvens och returnerar det lägsta null-värdet Double .
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)	Anropar en transformeringsfunktion på varje element i en sekvens och returnerar det lägsta null-värdet Int32 .
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)	Anropar en transformeringsfunktion på varje element i en sekvens och returnerar det lägsta null-värdet Int64 .
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Anropar en transformeringsfunktion på varje element i en sekvens och returnerar det lägsta null-värdet Single .
Min<TSource>(IEnumerable<TSource>, Func<TSource,Single>)	Anropar en transformeringsfunktion på varje element i en sekvens och returnerar minimivärdet Single .
Min<TSource>(IEnumerable<TSource>)	Returnerar minimivärdet i en allmän sekvens.
Nodes<T>(IEnumerable<T>)	Returnerar en samling av de underordnade noderna i varje dokument och element i källsamlingen.
OfType<TResult>(IEnumerable)	Filtrerar elementen i en IEnumerable baserat på en angiven typ.
OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)	Sorterar elementen i en sekvens i stigande ordning med hjälp av en angiven jämförelse.
OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Sorterar elementen i en sekvens i stigande ordning enligt en nyckel.
OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)	Sorterar elementen i en sekvens i fallande ordning med hjälp av en angiven jämförelse.
OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Sorterar elementen i en sekvens i fallande ordning enligt en nyckel.
Prepend<TSource>(IEnumerable<TSource>, TSource)	Lägger till ett värde i början av sekvensen.
Remove<T>(IEnumerable<T>)	Tar bort varje nod i källsamlingen från den överordnade noden.
Remove<TKey,TValue>(IDictionary<TKey,TValue>, TKey, TValue)	Försöker ta bort värdet med angivet `key` från `dictionary`.
Reverse<TSource>(IEnumerable<TSource>)	Invertera ordningen på elementen i en sekvens.
Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,TResult>)	Projicerar varje element i en sekvens i ett nytt formulär genom att införliva elementets index.
Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)	Projicerar varje element i en sekvens till ett nytt formulär.
SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)	Projicerar varje element i en sekvens till en IEnumerable<T>, jämnar ut de resulterande sekvenserna i en sekvens och anropar en resultatväljarefunktion på varje element däri.
SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)	Projicerar varje element i en sekvens till en IEnumerable<T>, jämnar ut de resulterande sekvenserna i en sekvens och anropar en resultatväljarefunktion på varje element däri. Indexet för varje källelement används i den mellanliggande projekterade formen av det elementet.
SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>)	Projicerar varje element i en sekvens till en IEnumerable<T> och jämnar ut de resulterande sekvenserna i en sekvens.
SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>)	Projicerar varje element i en sekvens till en IEnumerable<T>, och jämnar ut de resulterande sekvenserna i en sekvens. Indexet för varje källelement används i den projekterade formen av det elementet.
SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Avgör om två sekvenser är lika med genom att jämföra deras element med hjälp av en angiven IEqualityComparer<T>.
SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Avgör om två sekvenser är lika med genom att jämföra elementen med hjälp av standardjämlikhetsjämföraren för deras typ.
Single<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Returnerar det enda elementet i en sekvens som uppfyller ett angivet villkor och genererar ett undantag om mer än ett sådant element finns.
Single<TSource>(IEnumerable<TSource>)	Returnerar det enda elementet i en sekvens och genererar ett undantag om det inte finns exakt ett element i sekvensen.
SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Returnerar det enda elementet i en sekvens som uppfyller ett angivet villkor eller ett standardvärde om det inte finns något sådant element. den här metoden utlöser ett undantag om fler än ett element uppfyller villkoret.
SingleOrDefault<TSource>(IEnumerable<TSource>)	Returnerar det enda elementet i en sekvens eller ett standardvärde om sekvensen är tom. den här metoden utlöser ett undantag om det finns fler än ett element i sekvensen.
Skip<TSource>(IEnumerable<TSource>, Int32)	Kringgår ett angivet antal element i en sekvens och returnerar sedan de återstående elementen.
SkipLast<TSource>(IEnumerable<TSource>, Int32)	Returnerar en ny uppräkningsbar samling som innehåller elementen från `source` med de sista `count` elementen i källsamlingen som utelämnas.
SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Kringgår element i en sekvens så länge ett angivet villkor är sant och returnerar sedan de återstående elementen.
SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)	Kringgår element i en sekvens så länge ett angivet villkor är sant och returnerar sedan de återstående elementen. Elementets index används i logiken i predikatfunktionen.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Beräknar summan av sekvensen med Decimal värden som hämtas genom att anropa en transformeringsfunktion på varje element i indatasekvensen.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Beräknar summan av sekvensen med Double värden som hämtas genom att anropa en transformeringsfunktion på varje element i indatasekvensen.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)	Beräknar summan av sekvensen med Int32 värden som hämtas genom att anropa en transformeringsfunktion på varje element i indatasekvensen.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)	Beräknar summan av sekvensen med Int64 värden som hämtas genom att anropa en transformeringsfunktion på varje element i indatasekvensen.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)	Beräknar summan av sekvensen med null-värden Decimal som erhålls genom att anropa en transformeringsfunktion på varje element i indatasekvensen.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)	Beräknar summan av sekvensen med null-värden Double som erhålls genom att anropa en transformeringsfunktion på varje element i indatasekvensen.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)	Beräknar summan av sekvensen med null-värden Int32 som erhålls genom att anropa en transformeringsfunktion på varje element i indatasekvensen.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)	Beräknar summan av sekvensen med null-värden Int64 som erhålls genom att anropa en transformeringsfunktion på varje element i indatasekvensen.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Beräknar summan av sekvensen med null-värden Single som erhålls genom att anropa en transformeringsfunktion på varje element i indatasekvensen.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Single>)	Beräknar summan av sekvensen med Single värden som hämtas genom att anropa en transformeringsfunktion på varje element i indatasekvensen.
Take<TSource>(IEnumerable<TSource>, Int32)	Returnerar ett angivet antal sammanhängande element från början av en sekvens.
TakeLast<TSource>(IEnumerable<TSource>, Int32)	Returnerar en ny uppräkningsbar samling som innehåller de sista `count` elementen från `source`.
TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Returnerar element från en sekvens så länge ett angivet villkor är sant.
TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)	Returnerar element från en sekvens så länge ett angivet villkor är sant. Elementets index används i logiken i predikatfunktionen.
ToArray<TSource>(IEnumerable<TSource>)	Skapar en matris från en IEnumerable<T>.
ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	Skapar en Dictionary<TKey,TValue> från en IEnumerable<T> enligt en angiven nyckelväljare, en jämförelsefunktion och en elementväljare.
ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)	Skapar en Dictionary<TKey,TValue> från en IEnumerable<T> enligt angivna funktioner för nyckelväljare och elementväljare.
ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Skapar en Dictionary<TKey,TValue> från en IEnumerable<T> enligt en angiven nyckelväljare och nyckeljäxare.
ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Skapar en Dictionary<TKey,TValue> från en IEnumerable<T> enligt en angiven nyckelväljare.
ToHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)	Skapar en HashSet<T> från en IEnumerable<T> med hjälp av `comparer` för att jämföra nycklar.
ToHashSet<TSource>(IEnumerable<TSource>)	Skapar en HashSet<T> från en IEnumerable<T>.
ToImmutableArray<TSource>(IEnumerable<TSource>)	Skapar en oföränderlig matris från den angivna samlingen.
ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>, IEqualityComparer<TValue>)	Räknar upp och transformerar en sekvens och skapar en oföränderlig ordlista med dess innehåll med hjälp av de angivna nyckel- och värdejäxorna.
ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>)	Räknar upp och transformerar en sekvens och skapar en oföränderlig ordlista med dess innehåll med hjälp av den angivna nyckeljäxaren.
ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>)	Räknar upp och transformerar en sekvens och skapar en oföränderlig ordlista med dess innehåll.
ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Konstruerar en oföränderlig ordlista baserat på en viss omvandling av en sekvens.
ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Konstruerar en oföränderlig ordlista från en befintlig samling element och tillämpar en transformeringsfunktion på källnycklarna.
ToImmutableHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)	Räknar upp en sekvens, skapar en oföränderlig hashuppsättning av innehållet och använder den angivna likhetsjämföraren för den angivna typen.
ToImmutableHashSet<TSource>(IEnumerable<TSource>)	Räknar upp en sekvens och skapar en oföränderlig hashuppsättning med dess innehåll.
ToImmutableList<TSource>(IEnumerable<TSource>)	Räknar upp en sekvens och skapar en oföränderlig lista över dess innehåll.
ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>, IEqualityComparer<TValue>)	Räknar upp och transformerar en sekvens och skapar en oföränderlig sorterad ordlista med dess innehåll med hjälp av de angivna nyckel- och värdejäxorna.
ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>)	Räknar upp och transformerar en sekvens och skapar en oföränderlig sorterad ordlista med dess innehåll med hjälp av den angivna nyckeljäxaren.
ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>)	Räknar upp och transformerar en sekvens och skapar en oföränderlig sorterad ordlista med dess innehåll.
ToImmutableSortedSet<TSource>(IEnumerable<TSource>, IComparer<TSource>)	Räknar upp en sekvens, skapar en oföränderlig sorterad uppsättning av dess innehåll och använder den angivna jämförelsen.
ToImmutableSortedSet<TSource>(IEnumerable<TSource>)	Räknar upp en sekvens och skapar en oföränderlig sorterad uppsättning av dess innehåll.
ToList<TSource>(IEnumerable<TSource>)	Skapar en List<T> från en IEnumerable<T>.
ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	Skapar en Lookup<TKey,TElement> från en IEnumerable<T> enligt en angiven nyckelväljare, en jämförelsefunktion och en elementväljare.
ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)	Skapar en Lookup<TKey,TElement> från en IEnumerable<T> enligt angivna funktioner för nyckelväljare och elementväljare.
ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Skapar en Lookup<TKey,TElement> från en IEnumerable<T> enligt en angiven nyckelväljare och nyckeljäxare.
ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Skapar en Lookup<TKey,TElement> från en IEnumerable<T> enligt en angiven nyckelväljare.
TryAdd<TKey,TValue>(IDictionary<TKey,TValue>, TKey, TValue)	Försöker lägga till den angivna `key` och `value` till `dictionary`.
Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Skapar uppsättningen union av två sekvenser med hjälp av en angiven IEqualityComparer<T>.
Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Skapar uppsättningsunionen med två sekvenser med hjälp av standardjämförlikningsjämföraren.
Where<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Filtrerar en sekvens med värden baserat på ett predikat.
Where<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)	Filtrerar en sekvens med värden baserat på ett predikat. Varje elements index används i logiken i predikatfunktionen.
Zip<TFirst,TSecond,TResult>(IEnumerable<TFirst>, IEnumerable<TSecond>, Func<TFirst,TSecond,TResult>)	Tillämpar en angiven funktion på motsvarande element i två sekvenser, vilket ger en sekvens av resultaten.

Gäller för

Trådsäkerhet

Alla offentliga och skyddade medlemmar ConcurrentDictionary<TKey,TValue> i är trådsäkra och kan användas samtidigt från flera trådar. Medlemmar som nås via ett av de gränssnitt som implementeras ConcurrentDictionary<TKey,TValue> , inklusive tilläggsmetoder, är dock inte garanterade att vara trådsäkra och kan behöva synkroniseras av anroparen.

Se även

Feedback

Var den här sidan till hjälp?