linq
Standardabfrageoperatoren

Bemerkungen

Verkettungsoperationen

Verkettung bezieht sich auf das Anfügen einer Sequenz an eine andere.

Concat

Verkettet zwei Sequenzen zu einer Sequenz.

Methodensyntax

// Concat

var numbers1 = new int[] { 1, 2, 3 };
var numbers2 = new int[] { 4, 5, 6 };

var numbers = numbers1.Concat(numbers2);

// numbers = { 1, 2, 3, 4, 5, 6 }

Abfragesyntax

// Not applicable.

Filtervorgänge

Das Filtern bezieht sich auf Vorgänge, bei denen die Ergebnismenge auf die Elemente beschränkt wird, die eine bestimmte Bedingung erfüllen.

Woher

Wählt Werte aus, die auf einer Prädikatfunktion basieren.

Methodensyntax

// Where

var numbers = new int[] { 1, 2, 3, 4, 5, 6, 7, 8 };

var evens = numbers.Where(n => n % 2 == 0);

// evens = { 2, 4, 6, 8 }

Abfragesyntax

// where

var numbers = new int[] { 1, 2, 3, 4, 5, 6, 7, 8 };

var odds = from n in numbers
           where n % 2 != 0
           select n;

// odds = { 1, 3, 5, 7 }

OfType

Wählt Werte aus, abhängig von ihrer Fähigkeit, in einen angegebenen Typ umgewandelt zu werden.

Methodensyntax

// OfType

var numbers = new object[] { 1, "one", 2, "two", 3, "three" };

var strings = numbers.OfType<string>();

// strings = { "one", "two", "three" }

Abfragesyntax

// Not applicable.

Schließen Sie sich dem Betrieb an

Eine Verknüpfung zweier Datenquellen ist die Verknüpfung von Objekten in einer Datenquelle mit Objekten, die ein gemeinsames Attribut in einer anderen Datenquelle gemeinsam nutzen.

Beitreten

Verbindet zwei Sequenzen basierend auf Schlüsselauswahlfunktionen und extrahiert Wertepaare.

Methodensyntax

// Join

class Customer
{
    public int Id { get; set; }
    public string Name { get; set; }
}

class Order
{
    public string Description { get; set; }
    public int CustomerId { get; set; }
}
...

var customers = new Customer[] 
{
    new Customer { Id = 1, Name = "C1" },
    new Customer { Id = 2, Name = "C2" },
    new Customer { Id = 3, Name = "C3" }
};

var orders = new Order[]
{
    new Order { Description = "O1", CustomerId = 1 },
    new Order { Description = "O2", CustomerId = 1 },
    new Order { Description = "O3", CustomerId = 2 },
    new Order { Description = "O4", CustomerId = 3 },
};

var join = customers.Join(orders, c => c.Id, o => o.CustomerId, (c, o) => c.Name + "-" + o.Description);

// join = { "C1-O1", "C1-O2", "C2-O3", "C3-O4" }

Abfragesyntax

// join … in … on … equals …

var join = from c in customers
           join o in orders
           on c.Id equals o.CustomerId
           select o.Description + "-" + c.Name;

// join = { "O1-C1", "O2-C1", "O3-C2", "O4-C3" }

GroupJoin

Verbindet zwei Sequenzen basierend auf Schlüsselauswahlfunktionen und gruppiert die resultierenden Übereinstimmungen für jedes Element.

Methodensyntax

// GroupJoin

var groupJoin = customers.GroupJoin(orders,
                                    c => c.Id, 
                                    o => o.CustomerId, 
                                    (c, ors) => c.Name + "-" + string.Join(",", ors.Select(o => o.Description)));

// groupJoin = { "C1-O1,O2", "C2-O3", "C3-O4" }

Abfragesyntax

// join … in … on … equals … into …

var groupJoin = from c in customers
                join o in orders               
                on c.Id equals o.CustomerId
                into customerOrders
                select string.Join(",", customerOrders.Select(o => o.Description)) + "-" + c.Name;

// groupJoin = { "O1,O2-C1", "O3-C2", "O4-C3" }

Postleitzahl

Wendet eine angegebene Funktion auf die entsprechenden Elemente von zwei Sequenzen an und erzeugt eine Sequenz der Ergebnisse.

var numbers = new [] { 1, 2, 3, 4, 5, 6 };
var words = new [] { "one", "two", "three" };

var numbersWithWords =
    numbers
    .Zip(
        words,
        (number, word) => new { number, word });

// Results

//| number | word   |
//| ------ | ------ |
//| 1      |  one   |
//| 2      |  two   |
//| 3      |  three |

Projektionsvorgänge

Projektion bezieht sich auf die Operationen zum Umwandeln eines Objekts in eine neue Form.

Wählen

Projiziert Werte, die auf einer Transformationsfunktion basieren.

Methodensyntax

// Select

var numbers = new int[] { 1, 2, 3, 4, 5 };

var strings = numbers.Select(n => n.ToString());

// strings = { "1", "2", "3", "4", "5" }

Abfragesyntax

// select

var numbers = new int[] { 1, 2, 3, 4, 5 };

var strings = from n in numbers
              select n.ToString();

// strings = { "1", "2", "3", "4", "5" }

SelectMany

Projiziert Wertfolgen, die auf einer Transformationsfunktion basieren, und glättet sie dann in eine Folge.

Methodensyntax

// SelectMany

class Customer
{
    public Order[] Orders { get; set; }
}

class Order
{
    public Order(string desc) { Description = desc; }
    public string Description { get; set; }
}
...

var customers = new Customer[] 
{
    new Customer { Orders = new Order[] { new Order("O1"), new Order("O2") } },
    new Customer { Orders = new Order[] { new Order("O3") } },
    new Customer { Orders = new Order[] { new Order("O4") } },
};

var orders = customers.SelectMany(c => c.Orders);

// orders = { Order("O1"), Order("O3"), Order("O3"), Order("O4") }

Abfragesyntax

// multiples from

var orders = from c in customers
             from o in c.Orders
             select o;

// orders = { Order("O1"), Order("O3"), Order("O3"), Order("O4") }

Sortiervorgänge

Bei einem Sortiervorgang werden die Elemente einer Sequenz anhand eines oder mehrerer Attribute sortiert.

Sortieren nach

Sortiert die Werte in aufsteigender Reihenfolge.

Methodensyntax

// OrderBy

var numbers = new int[] { 5, 4, 8, 2, 7, 1, 9, 3, 6 };

var ordered = numbers.OrderBy(n => n);

// ordered = { 1, 2, 3, 4, 5, 6, 7, 8, 9 }

Abfragesyntax

// orderby

var numbers = new int[] { 5, 4, 8, 2, 7, 1, 9, 3, 6 };

var ordered = from n in numbers
              orderby n
              select n;

// ordered = { 1, 2, 3, 4, 5, 6, 7, 8, 9 }

OrderByDescending

Sortiert die Werte in absteigender Reihenfolge.

Methodensyntax

// OrderByDescending

var numbers = new int[] { 5, 4, 8, 2, 7, 1, 9, 3, 6 };

var ordered = numbers.OrderByDescending(n => n);

// ordered = { 9, 8, 7, 6, 5, 4, 3, 2, 1 }

Abfragesyntax

// orderby

var numbers = new int[] { 5, 4, 8, 2, 7, 1, 9, 3, 6 };

var ordered = from n in numbers
              orderby n descending
              select n;

// ordered = { 9, 8, 7, 6, 5, 4, 3, 2, 1 }

ThenBy

Führt eine sekundäre Sortierung in aufsteigender Reihenfolge durch.

Methodensyntax

// ThenBy

string[] words = { "the", "quick", "brown", "fox", "jumps" };

var ordered = words.OrderBy(w => w.Length).ThenBy(w => w[0]);

// ordered = { "fox", "the", "brown", "jumps", "quick" }

Abfragesyntax

// orderby …, …

string[] words = { "the", "quick", "brown", "fox", "jumps" };

var ordered = from w in words
              orderby w.Length, w[0]
              select w;

// ordered = { "fox", "the", "brown", "jumps", "quick" }

ThenByDescending

Führt eine sekundäre Sortierung in absteigender Reihenfolge durch.

Methodensyntax

// ThenByDescending

string[] words = { "the", "quick", "brown", "fox", "jumps" };

var ordered = words.OrderBy(w => w[0]).ThenByDescending(w => w.Length);

// ordered = { "brown", "fox", "jumps", "quick", "the" }

Abfragesyntax

// orderby …, … descending

string[] words = { "the", "quick", "brown", "fox", "jumps" };

var ordered = from w in words
              orderby w.Length, w[0] descending
              select w;

// ordered = { "the", "fox", "quick", "jumps", "brown" }

Umkehren

Kehrt die Reihenfolge der Elemente in einer Sammlung um.

Methodensyntax

// Reverse

var numbers = new int[] { 1, 2, 3, 4, 5 };

var reversed = numbers.Reverse();

// reversed = { 5, 4, 3, 2, 1 }

Abfragesyntax

// Not applicable.

Konvertierungsvorgänge

Konvertierungsvorgänge ändern den Typ der Eingabeobjekte.

AsUnumerable

Gibt die Eingabe zurück, die als IEnumerable eingegeben wurde.

Methodensyntax

// AsEnumerable

int[] numbers = { 1, 2, 3, 4, 5 };

var nums = numbers.AsEnumerable();

// nums: static type is IEnumerable<int>

Abfragesyntax

// Not applicable.

AsQueryable

Konvertiert ein IEnumerable in ein IQueryable.

Methodensyntax

// AsQueryable

int[] numbers = { 1, 2, 3, 4, 5 };

var nums = numbers.AsQueryable();

// nums: static type is IQueryable<int>

Abfragesyntax

// Not applicable.

Besetzung

Wandelt die Elemente einer Sammlung in einen angegebenen Typ um.

Methodensyntax

// Cast

var numbers = new object[] { 1, 2, 3, 4, 5 };

var nums = numbers.Cast<int>();

// nums: static type is IEnumerable<int>

Abfragesyntax

// Use an explicitly typed range variable.

var numbers = new object[] { 1, 2, 3, 4, 5 };

var nums = from int n in numbers select n;

// nums: static type is IEnumerable<int>

OfType

Filtert Werte, abhängig von ihrer Fähigkeit, in einen angegebenen Typ umgewandelt zu werden.

Methodensyntax

// OfType

var objects = new object[] { 1, "one", 2, "two", 3, "three" };

var numbers = objects.OfType<int>();

// nums = { 1, 2, 3 }

Abfragesyntax

// Not applicable.

ToArray

Konvertiert eine Auflistung in ein Array.

Methodensyntax

// ToArray

var numbers = Enumerable.Range(1, 5);

int[] array = numbers.ToArray();

// array = { 1, 2, 3, 4, 5 }

Abfragesyntax

// Not applicable.

Auflisten

Konvertiert eine Sammlung in eine Liste.

Methodensyntax

// ToList

var numbers = Enumerable.Range(1, 5);

List<int> list = numbers.ToList();

// list = { 1, 2, 3, 4, 5 }

Abfragesyntax

// Not applicable.

ToDictionary

Fügt Elemente in ein Wörterbuch ein, das auf einer Tastenauswahlfunktion basiert.

Methodensyntax

// ToDictionary

var numbers = new int[] { 1, 2, 3 };

var dict = numbers.ToDictionary(n => n.ToString());

// dict = { "1" => 1, "2" => 2, "3" => 3 }

Abfragesyntax

// Not applicable.

Aggregationsvorgänge

Aggregationsoperationen berechnen einen einzelnen Wert aus einer Sammlung von Werten.

Aggregat

Führt eine benutzerdefinierte Aggregationsoperation für die Werte einer Auflistung durch.

Methodensyntax

// Aggregate

var numbers = new int[] { 1, 2, 3, 4, 5 };

var product = numbers.Aggregate(1, (acc, n) => acc * n);

// product = 120

Abfragesyntax

// Not applicable.

Durchschnittlich

Berechnet den Durchschnittswert einer Wertesammlung.

Methodensyntax

// Average

var numbers = new int[] { 1, 2, 3, 4, 5 };

var average = numbers.Average();

// average = 3

Abfragesyntax

// Not applicable.

Anzahl

Zählt die Elemente in einer Auflistung, optional nur die Elemente, die eine Prädikatfunktion erfüllen.

Methodensyntax

// Count

var numbers = new int[] { 1, 2, 3, 4, 5 };

int count = numbers.Count(n => n % 2 == 0);

// count = 2

Abfragesyntax

// Not applicable.

LongCount

Zählt die Elemente in einer großen Sammlung, optional nur die Elemente, die eine Prädikatfunktion erfüllen.

Methodensyntax

// LongCount

var numbers = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

long count = numbers.LongCount();

// count = 10

Abfragesyntax

// Not applicable.

Max

Bestimmt den Maximalwert in einer Sammlung. Löst eine Ausnahme aus, wenn die Sammlung leer ist.

Methodensyntax

// Max

var numbers = new int[] { 1, 2, 3, 4, 5 };

var max = numbers.Max();

// max = 5

Abfragesyntax

// Not applicable.

Mindest

Bestimmt den Mindestwert in einer Sammlung. Löst eine Ausnahme aus, wenn die Sammlung leer ist.

Methodensyntax

// Min

var numbers = new int[] { 1, 2, 3, 4, 5 };

var min = numbers.Min();

// min = 1

Abfragesyntax

// Not applicable.

Min- / MaxOrDefault

Im Gegensatz zu anderen LinQ-Erweiterungen haben Min() und Max() ausnahmslos keine Überladung. Deshalb muss das IEnumerable vor dem Aufruf von Min() oder Max() auf Any() geprüft werden.

// Max

var numbers = new int[] { };

var max = numbers.Any() ? numbers.Max() : 0;

// max = 0

Summe

Berechnet die Summe der Werte in einer Sammlung.

Methodensyntax

// Sum

var numbers = new int[] { 1, 2, 3, 4, 5 };

var sum = numbers.Sum();

// sum = 15

Abfragesyntax

// Not applicable.

Quantifizierer-Operationen

Quantifizierungsoperationen geben einen booleschen Wert zurück, der angibt, ob einige oder alle Elemente einer Sequenz eine Bedingung erfüllen.

Alles

Bestimmt, ob alle Elemente in einer Sequenz eine Bedingung erfüllen.

Methodensyntax

// All

var numbers = new int[] { 1, 2, 3, 4, 5 };

bool areLessThan10 = numbers.All(n => n < 10);

// areLessThan10 = true

Abfragesyntax

// Not applicable.

Irgendein

Bestimmt, ob Elemente in einer Sequenz eine Bedingung erfüllen.

Methodensyntax

// Any

var numbers = new int[] { 1, 2, 3, 4, 5 };

bool anyOneIsEven = numbers.Any(n => n % 2 == 0);

// anyOneIsEven = true

Abfragesyntax

// Not applicable.

Enthält

Bestimmt, ob eine Sequenz ein angegebenes Element enthält.

Methodensyntax

// Contains

var numbers = new int[] { 1, 2, 3, 4, 5 };

bool appears = numbers.Contains(10);

// appears = false

Abfragesyntax

// Not applicable.

Gruppieren von Operationen

Gruppieren bezieht sich auf die Vorgänge, bei denen Daten in Gruppen angeordnet werden, sodass die Elemente in jeder Gruppe ein gemeinsames Attribut verwenden.

Gruppiere nach

Gruppiert Elemente mit einem gemeinsamen Attribut.

Methodensyntax

// GroupBy

class Order
{
    public string Customer { get; set; }
    public string Description { get; set; }
}
...

var orders = new Order[] 
{
    new Order { Customer = "C1", Description = "O1" },
    new Order { Customer = "C2", Description = "O2" },
    new Order { Customer = "C3", Description = "O3" },
    new Order { Customer = "C1", Description = "O4" },
    new Order { Customer = "C1", Description = "O5" },
    new Order { Customer = "C3", Description = "O6" },
};

var groups = orders.GroupBy(o => o.Customer);

// groups: { (Key="C1", Values="O1","O4","O5"), (Key="C2", Values="O2"), (Key="C3", Values="O3","O6") }

Abfragesyntax

// group … by

var groups = from o in orders
             group o by o.Customer;

// groups: { (Key="C1", Values="O1","O4","O5"), (Key="C2", Values="O2"), (Key="C3", Values="O3","O6") }

Nachschlagen

Fügt Elemente basierend auf einer Schlüsselauswahlfunktion in ein One-to-Many-Wörterbuch ein.

Methodensyntax

// ToLookUp

var ordersByCustomer = orders.ToLookup(o => o.Customer);

// ordersByCustomer = ILookUp<string, Order>
// {
//     "C1" => { Order("01"), Order("04"), Order("05") },
//     "C2" => { Order("02") },
//     "C3" => { Order("03"), Order("06") }
// }

Abfragesyntax

// Not applicable.

Partitionierungsvorgänge

Partitionieren bezieht sich auf das Aufteilen einer Eingabesequenz in zwei Abschnitte, ohne die Elemente neu anzuordnen, und dann einen der Abschnitte zurückzugeben.

Überspringen

Überspringt Elemente bis zu einer angegebenen Position in einer Sequenz.

Methodensyntax

// Skip

var numbers = new int[] { 1, 2, 3, 4, 5 };

var skipped = numbers.Skip(3);

// skipped = { 4, 5 }

Abfragesyntax

// Not applicable.

SkipWährend

Überspringt Elemente basierend auf einer Prädikatsfunktion, bis ein Element die Bedingung nicht erfüllt.

Methodensyntax

// Skip

var numbers = new int[] { 1, 3, 5, 2, 1, 3, 5 };

var skipLeadingOdds = numbers.SkipWhile(n => n % 2 != 0);

// skipLeadingOdds = { 2, 1, 3, 5 }

Abfragesyntax

// Not applicable.

Nehmen

Bringt Elemente an eine bestimmte Position in einer Sequenz.

Methodensyntax

// Take

var numbers = new int[] { 1, 2, 3, 4, 5 };

var taken = numbers.Take(3);

// taken = { 1, 2, 3 }

Abfragesyntax

// Not applicable.

TakeWhile

Verwendet Elemente basierend auf einer Prädikatsfunktion, bis ein Element die Bedingung nicht erfüllt.

Methodensyntax

// TakeWhile

var numbers = new int[] { 1, 3, 5, 2, 1, 3, 5 };

var takeLeadingOdds = numbers.TakeWhile(n => n % 2 != 0);

// takeLeadingOdds = { 1, 3, 5 }

Abfragesyntax

// Not applicable.

Erzeugungsbetrieb

Generierung bezieht sich auf das Erstellen einer neuen Wertefolge.

DefaultIfEmpty

Ersetzt eine leere Sammlung durch eine Singleton-Sammlung mit einem Standardwert.

Methodensyntax

// DefaultIfEmpty

var nums = new int[0];

var numbers = nums.DefaultIfEmpty();

// numbers = { 0 }

Abfragesyntax

// Not applicable.

Leeren

Gibt eine leere Sammlung zurück.

Methodensyntax

// Empty

var empty = Enumerable.Empty<string>();

// empty = IEnumerable<string> { }

Abfragesyntax

// Not applicable.

Angebot

Erzeugt eine Sammlung, die eine Zahlenfolge enthält.

Methodensyntax

// Range

var range = Enumerable.Range(1, 5);

// range = { 1, 2, 3, 4, 5 }

Abfragesyntax

// Not applicable.

Wiederholen

Erzeugt eine Auflistung, die einen wiederholten Wert enthält.

Methodensyntax

// Repeat

var repeats = Enumerable.Repeat("s", 3);

// repeats = { "s", "s", "s" }

Abfragesyntax

// Not applicable.

Operationen einstellen

Mengenoperationen beziehen sich auf Abfrageoperationen, die eine Ergebnismenge erzeugen, die auf dem Vorhandensein oder Fehlen gleichwertiger Elemente in derselben oder in separaten Sammlungen (oder Gruppen) basiert.

Eindeutig

Entfernt doppelte Werte aus einer Sammlung.

Methodensyntax

// Distinct

var numbers = new int[] { 1, 2, 3, 1, 2, 3 };

var distinct = numbers.Distinct();

// distinct = { 1, 2, 3 }

Abfragesyntax

// Not applicable.

Außer

Gibt die eingestellte Differenz zurück, d. H. Die Elemente einer Sammlung, die nicht in einer zweiten Sammlung angezeigt werden.

Methodensyntax

// Except

var numbers1 = new int[] { 1, 2, 3, 4, 5 };
var numbers2 = new int[] { 4, 5, 6, 7, 8 };

var except = numbers1.Except(numbers2);

// except = { 1, 2, 3 }

Abfragesyntax

// Not applicable.

Sich schneiden

Gibt die gesetzte Schnittmenge zurück, d. H. Elemente, die in jeder der zwei Auflistungen angezeigt werden.

Methodensyntax

// Intersect

var numbers1 = new int[] { 1, 2, 3, 4, 5 };
var numbers2 = new int[] { 4, 5, 6, 7, 8 };

var intersect = numbers1.Intersect(numbers2);

// intersect = { 4, 5 }

Abfragesyntax

// Not applicable.

Union

Gibt die Mengenvereinigung zurück, dh eindeutige Elemente, die in einer der beiden Sammlungen angezeigt werden.

Methodensyntax

// Union

var numbers1 = new int[] { 1, 2, 3, 4, 5 };
var numbers2 = new int[] { 4, 5, 6, 7, 8 };

var union = numbers1.Union(numbers2);

// union = { 1, 2, 3, 4, 5, 6, 7, 8 }

Abfragesyntax

// Not applicable.

Gleichstellungsoperationen

Zwei Folgen, deren entsprechende Elemente gleich sind und die gleiche Anzahl von Elementen haben, werden als gleich betrachtet.

SequenceEqual

Bestimmt, ob zwei Sequenzen gleich sind, indem Elemente paarweise verglichen werden.

Methodensyntax

// SequenceEqual

var numbers1 = new int[] { 1, 2, 3, 4, 5 };
var numbers2 = new int[] { 1, 2, 3, 4, 5 };

var equals = numbers1.SequenceEqual(numbers2);

// equals = true

Abfragesyntax

// Not Applicable.

Elementoperationen

Elementoperationen geben ein einzelnes, spezifisches Element aus einer Sequenz zurück.

ElementAt

Gibt das Element an einem angegebenen Index in einer Auflistung zurück.

Methodensyntax

// ElementAt

var strings = new string[] { "zero", "one", "two", "three" };

var str = strings.ElementAt(2);

// str = "two"

Abfragesyntax

// Not Applicable.

ElementAtOrDefault

Gibt das Element an einem angegebenen Index in einer Auflistung oder einen Standardwert zurück, wenn der Index außerhalb des gültigen Bereichs liegt.

Methodensyntax

// ElementAtOrDefault

var strings = new string[] { "zero", "one", "two", "three" };

var str = strings.ElementAtOrDefault(10);

// str = null

Abfragesyntax

// Not Applicable.

Zuerst

Gibt das erste Element einer Sammlung oder das erste Element zurück, das eine Bedingung erfüllt.

Methodensyntax

// First

var numbers = new int[] { 1, 2, 3, 4, 5 };

var first = strings.First();

// first = 1

Abfragesyntax

// Not Applicable.

FirstOrDefault

Gibt das erste Element einer Sammlung oder das erste Element zurück, das eine Bedingung erfüllt. Gibt einen Standardwert zurück, wenn kein solches Element vorhanden ist.

Methodensyntax

// FirstOrDefault

var numbers = new int[] { 1, 2, 3, 4, 5 };

var firstGreaterThanTen = strings.FirstOrDefault(n => n > 10);

// firstGreaterThanTen = 0

Abfragesyntax

// Not Applicable.

Zuletzt

Gibt das letzte Element einer Collection oder das letzte Element zurück, das eine Bedingung erfüllt.

Methodensyntax

// Last

var numbers = new int[] { 1, 2, 3, 4, 5 };

var last = strings.Last();

// last = 5

Abfragesyntax

// Not Applicable.

LastOrDefault

Gibt das letzte Element einer Collection oder das letzte Element zurück, das eine Bedingung erfüllt. Gibt einen Standardwert zurück, wenn kein solches Element vorhanden ist.

Methodensyntax

// LastOrDefault

var numbers = new int[] { 1, 2, 3, 4, 5 };

var lastGreaterThanTen = strings.LastOrDefault(n => n > 10);

// lastGreaterThanTen = 0

Abfragesyntax

// Not Applicable.

Single

Gibt das einzige Element einer Auflistung zurück oder das einzige Element, das eine Bedingung erfüllt.

Methodensyntax

// Single

var numbers = new int[] { 1 };

var single = strings.Single();

// single = 1

Abfragesyntax

// Not Applicable.

SingleOrDefault

Gibt das einzige Element einer Auflistung zurück oder das einzige Element, das eine Bedingung erfüllt. Gibt einen Standardwert zurück, wenn kein solches Element vorhanden ist oder die Auflistung nicht genau ein Element enthält.

Methodensyntax

// SingleOrDefault

var numbers = new int[] { 1, 2, 3, 4, 5 };

var singleGreaterThanFour = strings.SingleOrDefault(n => n > 4);

// singleGreaterThanFour = 5

Abfragesyntax

// Not Applicable.