linq
Standaard query-operators

Opmerkingen

Samenvoegingsoperaties

Aaneenschakeling verwijst naar de bewerking van het toevoegen van de ene reeks aan de andere.

concat

Combineert twee reeksen om één reeks te vormen.

Methode Syntaxis

// 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 }

Zoekopdrachtsyntaxis

// Not applicable.

Filterbewerkingen

Filteren verwijst naar de bewerkingen van het beperken van de resultatenset om alleen die elementen te bevatten die aan een gespecificeerde voorwaarde voldoen.

Waar

Selecteert waarden die zijn gebaseerd op een predikaatfunctie.

Methode Syntaxis

// 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 }

Zoekopdrachtsyntaxis

// 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

Hiermee selecteert u waarden, afhankelijk van hun vermogen om naar een bepaald type te casten.

Methode Syntaxis

// OfType

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

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

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

Zoekopdrachtsyntaxis

// Not applicable.

Neem deel aan bewerkingen

Een combinatie van twee gegevensbronnen is de associatie van objecten in een gegevensbron met objecten die een gemeenschappelijk kenmerk delen in een andere gegevensbron.

toetreden

Combineert twee reeksen op basis van sleutelfuncties en extraheert paren van waarden.

Methode Syntaxis

// 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" }

Zoekopdrachtsyntaxis

// 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

Combineert twee reeksen op basis van sleutelfuncties en groepeert de resulterende overeenkomsten voor elk element.

Methode Syntaxis

// 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" }

Zoekopdrachtsyntaxis

// 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" }

ritssluiting

Past een opgegeven functie toe op de overeenkomstige elementen van twee reeksen, waardoor een reeks resultaten wordt geproduceerd.

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 |

Projectie operaties

Projectie verwijst naar de bewerkingen van het transformeren van een object in een nieuwe vorm.

kiezen

Projecteert waarden die zijn gebaseerd op een transformatiefunctie.

Methode Syntaxis

// Select

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

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

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

Zoekopdrachtsyntaxis

// 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

Projecteert reeksen waarden die zijn gebaseerd op een transformatiefunctie en maakt ze vervolgens vlak in één reeks.

Methode Syntaxis

// 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") }

Zoekopdrachtsyntaxis

// multiples from

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

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

Sorteerbewerkingen

Een sorteerbewerking ordent de elementen van een reeks op basis van een of meer attributen.

OrderBy

Sorteert waarden in oplopende volgorde.

Methode Syntaxis

// 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 }

Zoekopdrachtsyntaxis

// 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

Sorteert waarden in aflopende volgorde.

Methode Syntaxis

// 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 }

Zoekopdrachtsyntaxis

// 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

Voert een secundaire sortering in oplopende volgorde uit.

Methode Syntaxis

// 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" }

Zoekopdrachtsyntaxis

// 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

Voert een secundaire sortering in aflopende volgorde uit.

Methode Syntaxis

// 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" }

Zoekopdrachtsyntaxis

// 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" }

Omgekeerde

Keert de volgorde van de elementen in een verzameling om.

Methode Syntaxis

// Reverse

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

var reversed = numbers.Reverse();

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

Zoekopdrachtsyntaxis

// Not applicable.

Conversiebewerkingen

Conversiebewerkingen veranderen het type invoerobjecten.

AsEnumerable

Retourneert de invoer getypt als IEnumerable.

Methode Syntaxis

// AsEnumerable

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

var nums = numbers.AsEnumerable();

// nums: static type is IEnumerable<int>

Zoekopdrachtsyntaxis

// Not applicable.

AsQueryable

Converteert een IEnumerable naar een IQueryable.

Methode Syntaxis

// AsQueryable

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

var nums = numbers.AsQueryable();

// nums: static type is IQueryable<int>

Zoekopdrachtsyntaxis

// Not applicable.

Gips

De elementen van een verzameling worden naar een bepaald type gegoten.

Methode Syntaxis

// Cast

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

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

// nums: static type is IEnumerable<int>

Zoekopdrachtsyntaxis

// 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 waarden, afhankelijk van hun vermogen om naar een bepaald type te casten.

Methode Syntaxis

// OfType

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

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

// nums = { 1, 2, 3 }

Zoekopdrachtsyntaxis

// Not applicable.

ToArray

Converteert een verzameling naar een array.

Methode Syntaxis

// ToArray

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

int[] array = numbers.ToArray();

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

Zoekopdrachtsyntaxis

// Not applicable.

ToList

Converteert een verzameling naar een lijst.

Methode Syntaxis

// ToList

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

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

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

Zoekopdrachtsyntaxis

// Not applicable.

ToDictionary

Zet elementen in een woordenboek op basis van een sleutelfunctie.

Methode Syntaxis

// ToDictionary

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

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

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

Zoekopdrachtsyntaxis

// Not applicable.

Aggregatie-operaties

Aggregatiebewerkingen berekenen een enkele waarde uit een verzameling waarden.

Aggregaat

Voert een aangepaste aggregatiebewerking uit op de waarden van een verzameling.

Methode Syntaxis

// Aggregate

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

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

// product = 120

Zoekopdrachtsyntaxis

// Not applicable.

Gemiddelde

Berekent de gemiddelde waarde van een verzameling waarden.

Methode Syntaxis

// Average

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

var average = numbers.Average();

// average = 3

Zoekopdrachtsyntaxis

// Not applicable.

tellen

Telt de elementen in een verzameling, optioneel alleen die elementen die voldoen aan een predikaatfunctie.

Methode Syntaxis

// Count

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

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

// count = 2

Zoekopdrachtsyntaxis

// Not applicable.

LongCount

Telt de elementen in een grote verzameling, optioneel alleen die elementen die voldoen aan een predikaatfunctie.

Methode Syntaxis

// LongCount

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

long count = numbers.LongCount();

// count = 10

Zoekopdrachtsyntaxis

// Not applicable.

Max

Bepaalt de maximale waarde in een verzameling. Gooit uitzondering als verzameling leeg is.

Methode Syntaxis

// Max

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

var max = numbers.Max();

// max = 5

Zoekopdrachtsyntaxis

// Not applicable.

min

Bepaalt de minimumwaarde in een verzameling. Gooit uitzondering als verzameling leeg is.

Methode Syntaxis

// Min

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

var min = numbers.Min();

// min = 1

Zoekopdrachtsyntaxis

// Not applicable.

Min- / MaxOrDefault

In tegenstelling tot andere LinQ-extensies hebben Min() en Max() geen overbelasting zonder uitzonderingen. Daarom moet de IEnumerable op Any() worden gecontroleerd voordat Min() of Max()

// Max

var numbers = new int[] { };

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

// max = 0

Som

Berekent de som van de waarden in een verzameling.

Methode Syntaxis

// Sum

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

var sum = numbers.Sum();

// sum = 15

Zoekopdrachtsyntaxis

// Not applicable.

Kwantificatiewerkzaamheden

Kwantificeerbewerkingen retourneren een Booleaanse waarde die aangeeft of sommige of alle elementen in een reeks aan een voorwaarde voldoen.

Allemaal

Bepaalt of alle elementen in een reeks aan een voorwaarde voldoen.

Methode Syntaxis

// All

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

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

// areLessThan10 = true

Zoekopdrachtsyntaxis

// Not applicable.

Ieder

Bepaalt of elementen in een reeks aan een voorwaarde voldoen.

Methode Syntaxis

// Any

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

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

// anyOneIsEven = true

Zoekopdrachtsyntaxis

// Not applicable.

bevat

Bepaalt of een reeks een gespecificeerd element bevat.

Methode Syntaxis

// Contains

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

bool appears = numbers.Contains(10);

// appears = false

Zoekopdrachtsyntaxis

// Not applicable.

Groeperingsactiviteiten

Groeperen verwijst naar de bewerkingen waarbij gegevens in groepen worden geplaatst, zodat de elementen in elke groep een gemeenschappelijk kenmerk delen.

GroupBy

Groepeert elementen die een gemeenschappelijk kenmerk delen.

Methode Syntaxis

// 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") }

Zoekopdrachtsyntaxis

// 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") }

Opkijken

Voegt elementen in een één-op-veel woordenboek in op basis van een sleutelfunctie.

Methode Syntaxis

// 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") }
// }

Zoekopdrachtsyntaxis

// Not applicable.

Partitie bewerkingen

Partitioneren verwijst naar de bewerkingen van het verdelen van een invoerreeks in twee secties, zonder de elementen opnieuw te rangschikken en vervolgens een van de secties terug te geven.

Overspringen

Slaat elementen over naar een opgegeven positie in een reeks.

Methode Syntaxis

// Skip

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

var skipped = numbers.Skip(3);

// skipped = { 4, 5 }

Zoekopdrachtsyntaxis

// Not applicable.

SkipWhile

Slaat elementen over op basis van een predikaatfunctie totdat een element niet aan de voorwaarde voldoet.

Methode Syntaxis

// 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 }

Zoekopdrachtsyntaxis

// Not applicable.

Nemen

Brengt elementen naar een opgegeven positie in een reeks.

Methode Syntaxis

// Take

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

var taken = numbers.Take(3);

// taken = { 1, 2, 3 }

Zoekopdrachtsyntaxis

// Not applicable.

takeWhile

Neemt elementen op basis van een predikaatfunctie totdat een element niet aan de voorwaarde voldoet.

Methode Syntaxis

// TakeWhile

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

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

// takeLeadingOdds = { 1, 3, 5 }

Zoekopdrachtsyntaxis

// Not applicable.

Generatie bewerkingen

Generatie verwijst naar het creëren van een nieuwe reeks waarden.

DefaultIfEmpty

Vervangt een lege verzameling door een standaard gewaardeerde singleton-verzameling.

Methode Syntaxis

// DefaultIfEmpty

var nums = new int[0];

var numbers = nums.DefaultIfEmpty();

// numbers = { 0 }

Zoekopdrachtsyntaxis

// Not applicable.

Leeg

Retourneert een lege verzameling.

Methode Syntaxis

// Empty

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

// empty = IEnumerable<string> { }

Zoekopdrachtsyntaxis

// Not applicable.

reeks

Genereert een verzameling die een reeks getallen bevat.

Methode Syntaxis

// Range

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

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

Zoekopdrachtsyntaxis

// Not applicable.

Herhaling

Genereert een verzameling die één herhaalde waarde bevat.

Methode Syntaxis

// Repeat

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

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

Zoekopdrachtsyntaxis

// Not applicable.

Bewerkingen instellen

Setbewerkingen verwijzen naar querybewerkingen die een resultatenset produceren die is gebaseerd op de aanwezigheid of afwezigheid van equivalente elementen binnen dezelfde of afzonderlijke collecties (of sets).

onderscheiden

Hiermee verwijdert u dubbele waarden uit een verzameling.

Methode Syntaxis

// Distinct

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

var distinct = numbers.Distinct();

// distinct = { 1, 2, 3 }

Zoekopdrachtsyntaxis

// Not applicable.

Behalve

Retourneert het ingestelde verschil, wat betekent dat de elementen van een verzameling niet in een tweede verzameling worden weergegeven.

Methode Syntaxis

// 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 }

Zoekopdrachtsyntaxis

// Not applicable.

Snijden

Retourneert het ingestelde snijpunt, wat betekent dat elementen in elk van de twee collecties verschijnen.

Methode Syntaxis

// 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 }

Zoekopdrachtsyntaxis

// Not applicable.

Unie

Retourneert de ingestelde unie, wat unieke elementen betekent die in een van de twee collecties verschijnen.

Methode Syntaxis

// 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 }

Zoekopdrachtsyntaxis

// Not applicable.

Gelijkheidsoperaties

Twee reeksen waarvan de overeenkomstige elementen gelijk zijn en die hetzelfde aantal elementen hebben, worden als gelijk beschouwd.

SequenceEqual

Bepaalt of twee sequenties gelijk zijn door elementen paarsgewijs te vergelijken.

Methode Syntaxis

// 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

Zoekopdrachtsyntaxis

// Not Applicable.

Elementbewerkingen

Elementbewerkingen retourneren een enkel, specifiek element uit een reeks.

ElementAt

Retourneert het element op een opgegeven index in een verzameling.

Methode Syntaxis

// ElementAt

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

var str = strings.ElementAt(2);

// str = "two"

Zoekopdrachtsyntaxis

// Not Applicable.

ElementAtOrDefault

Retourneert het element met een opgegeven index in een verzameling of een standaardwaarde als de index buiten bereik is.

Methode Syntaxis

// ElementAtOrDefault

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

var str = strings.ElementAtOrDefault(10);

// str = null

Zoekopdrachtsyntaxis

// Not Applicable.

Eerste

Retourneert het eerste element van een verzameling of het eerste element dat aan een voorwaarde voldoet.

Methode Syntaxis

// First

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

var first = strings.First();

// first = 1

Zoekopdrachtsyntaxis

// Not Applicable.

FirstOrDefault

Retourneert het eerste element van een verzameling of het eerste element dat aan een voorwaarde voldoet. Retourneert een standaardwaarde als een dergelijk element niet bestaat.

Methode Syntaxis

// FirstOrDefault

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

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

// firstGreaterThanTen = 0

Zoekopdrachtsyntaxis

// Not Applicable.

Laatste

Retourneert het laatste element van een verzameling of het laatste element dat aan een voorwaarde voldoet.

Methode Syntaxis

// Last

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

var last = strings.Last();

// last = 5

Zoekopdrachtsyntaxis

// Not Applicable.

LastOrDefault

Retourneert het laatste element van een verzameling of het laatste element dat aan een voorwaarde voldoet. Retourneert een standaardwaarde als een dergelijk element niet bestaat.

Methode Syntaxis

// LastOrDefault

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

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

// lastGreaterThanTen = 0

Zoekopdrachtsyntaxis

// Not Applicable.

single

Retourneert het enige element van een verzameling of het enige element dat aan een voorwaarde voldoet.

Methode Syntaxis

// Single

var numbers = new int[] { 1 };

var single = strings.Single();

// single = 1

Zoekopdrachtsyntaxis

// Not Applicable.

SingleOrDefault

Retourneert het enige element van een verzameling of het enige element dat aan een voorwaarde voldoet. Retourneert een standaardwaarde als een dergelijk element niet bestaat of de verzameling niet exact één element bevat.

Methode Syntaxis

// SingleOrDefault

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

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

// singleGreaterThanFour = 5

Zoekopdrachtsyntaxis

// Not Applicable.