linq
Standardfrågefunktörer

Anmärkningar

Samkopplingsoperationer

Sammanfattning avser operationen att lägga till en sekvens till en annan.

concat

Sammanfogar två sekvenser för att bilda en sekvens.

Metodsyntax

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

Frågesyntax

// Not applicable.

Filtrering

Filtrering hänvisar till operationerna för att begränsa resultatset att endast innehålla de element som uppfyller ett specifikt villkor.

Var

Väljer värden som är baserade på en predikatfunktion.

Metodsyntax

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

Frågesyntax

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

Väljer värden, beroende på deras förmåga att kastas till en viss typ.

Metodsyntax

// OfType

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

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

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

Frågesyntax

// Not applicable.

Gå med i verksamheten

En sammanfogning av två datakällor är föreningen av objekt i en datakälla med objekt som delar ett gemensamt attribut i en annan datakälla.

Ansluta sig

Förenar två sekvenser baserade på tangentväljarfunktioner och extraherar värdepar.

Metodsyntax

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

Frågesyntax

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

Förenar två sekvenser baserade på tangentväljarfunktioner och grupperar de resulterande matchningarna för varje element.

Metodsyntax

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

Frågesyntax

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

Blixtlås

Tillämpar en specificerad funktion på motsvarande element i två sekvenser, vilket ger en sekvens av resultaten.

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 |

Projektionsoperationer

Projektion avser operationerna för att omvandla ett objekt till en ny form.

Välj

Projicerar värden som är baserade på en transformfunktion.

Metodsyntax

// Select

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

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

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

Frågesyntax

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

Projicerar sekvenser av värden som är baserade på en transformfunktion och sedan plattar dem i en sekvens.

Metodsyntax

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

Frågesyntax

// multiples from

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

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

Sortera operationer

En sorteringsoperation beställer elementen i en sekvens baserat på ett eller flera attribut.

Sortera efter

Sorterar värden i stigande ordning.

Metodsyntax

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

Frågesyntax

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

Sorterar värden i fallande ordning.

Metodsyntax

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

Frågesyntax

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

Utför en sekundär sortering i stigande ordning.

Metodsyntax

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

Frågesyntax

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

Utför en sekundär sortering i fallande ordning.

Metodsyntax

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

Frågesyntax

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

Omvänd

Omvända ordningen på elementen i en samling.

Metodsyntax

// Reverse

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

var reversed = numbers.Reverse();

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

Frågesyntax

// Not applicable.

Konvertering

Konverteringsoperationer ändrar typen av inmatningsobjekt.

AsEnumerable

Returnerar ingången typ IEnumerable.

Metodsyntax

// AsEnumerable

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

var nums = numbers.AsEnumerable();

// nums: static type is IEnumerable<int>

Frågesyntax

// Not applicable.

AsQueryable

Konverterar ett IEnumerable till en IQueryable.

Metodsyntax

// AsQueryable

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

var nums = numbers.AsQueryable();

// nums: static type is IQueryable<int>

Frågesyntax

// Not applicable.

Kasta

Lämnar elementen i en samling till en specifik typ.

Metodsyntax

// Cast

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

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

// nums: static type is IEnumerable<int>

Frågesyntax

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

Filtervärden, beroende på deras förmåga att kastas till en specifik typ.

Metodsyntax

// OfType

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

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

// nums = { 1, 2, 3 }

Frågesyntax

// Not applicable.

toArray

Konverterar en samling till en matris.

Metodsyntax

// ToArray

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

int[] array = numbers.ToArray();

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

Frågesyntax

// Not applicable.

Att lista

Konverterar en samling till en lista.

Metodsyntax

// ToList

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

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

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

Frågesyntax

// Not applicable.

ToDictionary

Lägger in element i en ordlista baserad på en knappvalsfunktion.

Metodsyntax

// ToDictionary

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

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

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

Frågesyntax

// Not applicable.

Aggregeringsoperationer

Aggregeringsoperationer beräknar ett enda värde från en samling värden.

Aggregate

Utför en anpassad aggregeringsoperation för värdena i en samling.

Metodsyntax

// Aggregate

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

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

// product = 120

Frågesyntax

// Not applicable.

Medel

Beräknar medelvärdet för en samling värden.

Metodsyntax

// Average

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

var average = numbers.Average();

// average = 3

Frågesyntax

// Not applicable.

Räkna

Räknar elementen i en samling, valfritt endast de element som uppfyller en predikatfunktion.

Metodsyntax

// Count

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

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

// count = 2

Frågesyntax

// Not applicable.

LongCount

Räknar elementen i en stor samling, valfritt endast de element som uppfyller en predikatfunktion.

Metodsyntax

// LongCount

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

long count = numbers.LongCount();

// count = 10

Frågesyntax

// Not applicable.

Max

Bestämmer det maximala värdet i en samling. Kasta undantag om samlingen är tom.

Metodsyntax

// Max

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

var max = numbers.Max();

// max = 5

Frågesyntax

// Not applicable.

min

Bestämmer minimivärdet i en samling. Kasta undantag om samlingen är tom.

Metodsyntax

// Min

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

var min = numbers.Min();

// min = 1

Frågesyntax

// Not applicable.

Min- / MaxOrDefault

Till skillnad från andra LinQ-tillägg har Min() och Max() inte en överbelastning utan undantag. Därför måste IEnumerable kontrolleras för Any() innan du ringer Min() eller Max()

// Max

var numbers = new int[] { };

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

// max = 0

Summa

Beräknar summan av värdena i en samling.

Metodsyntax

// Sum

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

var sum = numbers.Sum();

// sum = 15

Frågesyntax

// Not applicable.

Kvantifieringsoperationer

Kvantifieringsoperationer returnerar ett booleskt värde som anger om några eller alla element i en sekvens uppfyller ett villkor.

Allt

Bestämmer om alla element i en sekvens uppfyller ett villkor.

Metodsyntax

// All

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

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

// areLessThan10 = true

Frågesyntax

// Not applicable.

Några

Bestämmer om några element i en sekvens uppfyller ett villkor.

Metodsyntax

// Any

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

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

// anyOneIsEven = true

Frågesyntax

// Not applicable.

innehåller

Bestämmer om en sekvens innehåller ett specificerat element.

Metodsyntax

// Contains

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

bool appears = numbers.Contains(10);

// appears = false

Frågesyntax

// Not applicable.

Gruppera verksamhet

Gruppering avser operationerna för att lägga in data i grupper så att elementen i varje grupp delar ett gemensamt attribut.

Grupp av

Grupperar element som delar ett gemensamt attribut.

Metodsyntax

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

Frågesyntax

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

Att kolla upp

Infogar element i en en-till-många-ordlista baserad på en tangentväljarfunktion.

Metodsyntax

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

Frågesyntax

// Not applicable.

Partitionsoperationer

Partitionering hänvisar till operationerna för att dela in en ingångssekvens i två sektioner, utan att ordna om elementen och sedan returnera en av sektionerna.

Hoppa

Hoppar över element till en specificerad position i en sekvens.

Metodsyntax

// Skip

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

var skipped = numbers.Skip(3);

// skipped = { 4, 5 }

Frågesyntax

// Not applicable.

SkipWhile

Hoppar över element baserade på en predikatfunktion tills ett element inte uppfyller villkoret.

Metodsyntax

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

Frågesyntax

// Not applicable.

Ta

Tar element upp till en specifik position i en sekvens.

Metodsyntax

// Take

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

var taken = numbers.Take(3);

// taken = { 1, 2, 3 }

Frågesyntax

// Not applicable.

TakeWhile

Tar element baserat på en predikatfunktion tills ett element inte uppfyller villkoret.

Metodsyntax

// TakeWhile

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

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

// takeLeadingOdds = { 1, 3, 5 }

Frågesyntax

// Not applicable.

Generationsoperationer

Generation avser att skapa en ny värdesekvens.

DefaultIfEmpty

Ersätter en tom samling med en standardvärderad singleton-samling.

Metodsyntax

// DefaultIfEmpty

var nums = new int[0];

var numbers = nums.DefaultIfEmpty();

// numbers = { 0 }

Frågesyntax

// Not applicable.

Tömma

Returnerar en tom samling.

Metodsyntax

// Empty

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

// empty = IEnumerable<string> { }

Frågesyntax

// Not applicable.

Räckvidd

Genererar en samling som innehåller en sekvens av siffror.

Metodsyntax

// Range

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

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

Frågesyntax

// Not applicable.

Upprepa

Genererar en samling som innehåller ett upprepat värde.

Metodsyntax

// Repeat

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

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

Frågesyntax

// Not applicable.

Ställ in operationer

Ställ in operationer hänvisar till frågefunktioner som producerar en resultatuppsättning som är baserad på närvaro eller frånvaro av ekvivalenta element i samma eller separata samlingar (eller uppsättningar).

Distinkt

Tar bort duplicerade värden från en samling.

Metodsyntax

// Distinct

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

var distinct = numbers.Distinct();

// distinct = { 1, 2, 3 }

Frågesyntax

// Not applicable.

Bortsett från

Returnerar den inställda skillnaden, vilket betyder elementen i en samling som inte visas i en andra samling.

Metodsyntax

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

Frågesyntax

// Not applicable.

Korsas

Returnerar inställd skärningspunkt, vilket betyder element som visas i var och en av två samlingar.

Metodsyntax

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

Frågesyntax

// Not applicable.

Union

Returnerar den inställda unionen, vilket betyder unika element som visas i någon av två samlingar.

Metodsyntax

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

Frågesyntax

// Not applicable.

Jämställdhetsoperationer

Två sekvenser vars motsvarande element är lika och som har samma antal element betraktas som lika.

SequenceEqual

Bestämmer om två sekvenser är lika genom att jämföra element på ett parvis sätt.

Metodsyntax

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

Frågesyntax

// Not Applicable.

Elementoperationer

Elementoperationer returnerar ett enda, specifikt element från en sekvens.

ElementAt

Returnerar elementet vid ett specificerat index i en samling.

Metodsyntax

// ElementAt

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

var str = strings.ElementAt(2);

// str = "two"

Frågesyntax

// Not Applicable.

ElementAtOrDefault

Returnerar elementet vid ett specificerat index i en samling eller ett standardvärde om indexet är utanför räckvidden.

Metodsyntax

// ElementAtOrDefault

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

var str = strings.ElementAtOrDefault(10);

// str = null

Frågesyntax

// Not Applicable.

Först

Returnerar det första elementet i en samling eller det första elementet som uppfyller ett villkor.

Metodsyntax

// First

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

var first = strings.First();

// first = 1

Frågesyntax

// Not Applicable.

FirstOrDefault

Returnerar det första elementet i en samling eller det första elementet som uppfyller ett villkor. Returnerar ett standardvärde om inget sådant element finns.

Metodsyntax

// FirstOrDefault

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

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

// firstGreaterThanTen = 0

Frågesyntax

// Not Applicable.

Sista

Returnerar det sista elementet i en samling eller det sista elementet som uppfyller ett villkor.

Metodsyntax

// Last

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

var last = strings.Last();

// last = 5

Frågesyntax

// Not Applicable.

LastOrDefault

Returnerar det sista elementet i en samling eller det sista elementet som uppfyller ett villkor. Returnerar ett standardvärde om inget sådant element finns.

Metodsyntax

// LastOrDefault

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

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

// lastGreaterThanTen = 0

Frågesyntax

// Not Applicable.

Enda

Returnerar det enda elementet i en samling, eller det enda elementet som uppfyller ett villkor.

Metodsyntax

// Single

var numbers = new int[] { 1 };

var single = strings.Single();

// single = 1

Frågesyntax

// Not Applicable.

SingleOrDefault

Returnerar det enda elementet i en samling, eller det enda elementet som uppfyller ett villkor. Returnerar ett standardvärde om inget sådant element finns eller samlingen inte innehåller exakt ett element.

Metodsyntax

// SingleOrDefault

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

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

// singleGreaterThanFour = 5

Frågesyntax

// Not Applicable.