linq
Standardowe operatory zapytań

Uwagi

Operacje konkatenacji

Łączenie odnosi się do operacji dołączania jednej sekwencji do drugiej.

Concat

Łączy dwie sekwencje, tworząc jedną sekwencję.

Metoda Składnia

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

Składnia zapytania

// Not applicable.

Filtrowanie operacji

Filtrowanie odnosi się do operacji ograniczania zestawu wyników, aby zawierał tylko te elementy, które spełniają określony warunek.

Gdzie

Wybiera wartości oparte na funkcji predykatu.

Metoda Składnia

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

Składnia zapytania

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

Wybiera wartości, w zależności od ich zdolności do rzutowania na określony typ.

Metoda Składnia

// OfType

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

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

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

Składnia zapytania

// Not applicable.

Dołącz do operacji

Połączenie dwóch źródeł danych polega na powiązaniu obiektów w jednym źródle danych z obiektami, które mają wspólny atrybut w innym źródle danych.

Przystąp

Łączy dwie sekwencje w oparciu o funkcje selektora klawiszy i wyodrębnia pary wartości.

Metoda Składnia

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

Składnia zapytania

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

Łączy dwie sekwencje w oparciu o funkcje selektora klawiszy i grupuje wynikowe dopasowania dla każdego elementu.

Metoda Składnia

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

Składnia zapytania

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

Zamek błyskawiczny

Stosuje określoną funkcję do odpowiednich elementów dwóch sekwencji, tworząc sekwencję wyników.

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 |

Operacje projekcyjne

Projekcja odnosi się do operacji przekształcania obiektu w nową formę.

Wybierz

Projektuje wartości oparte na funkcji transformacji.

Metoda Składnia

// Select

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

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

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

Składnia zapytania

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

Wybierz wiele

Projektuje sekwencje wartości oparte na funkcji transformacji, a następnie spłaszcza je w jedną sekwencję.

Metoda Składnia

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

Składnia zapytania

// multiples from

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

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

Operacje sortowania

Operacja sortowania porządkuje elementy sekwencji na podstawie jednego lub więcej atrybutów.

Zamów przez

Sortuje wartości w porządku rosnącym.

Metoda Składnia

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

Składnia zapytania

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

Sortuje wartości w kolejności malejącej.

Metoda Składnia

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

Składnia zapytania

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

Więc przez

Wykonuje sortowanie wtórne w porządku rosnącym.

Metoda Składnia

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

Składnia zapytania

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

Wykonuje sortowanie wtórne w kolejności malejącej.

Metoda Składnia

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

Składnia zapytania

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

Rewers

Odwraca kolejność elementów w kolekcji.

Metoda Składnia

// Reverse

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

var reversed = numbers.Reverse();

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

Składnia zapytania

// Not applicable.

Operacje konwersji

Operacje konwersji zmieniają typ obiektów wejściowych.

AsEnumerable

Zwraca dane wejściowe o typie IEnumerable.

Metoda Składnia

// AsEnumerable

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

var nums = numbers.AsEnumerable();

// nums: static type is IEnumerable<int>

Składnia zapytania

// Not applicable.

AsQueryable

Konwertuje IEnumerable na IQueryable.

Metoda Składnia

// AsQueryable

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

var nums = numbers.AsQueryable();

// nums: static type is IQueryable<int>

Składnia zapytania

// Not applicable.

Odlew

Rzuca elementy kolekcji na określony typ.

Metoda Składnia

// Cast

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

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

// nums: static type is IEnumerable<int>

Składnia zapytania

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

Filtruje wartości, w zależności od ich zdolności do rzutowania na określony typ.

Metoda Składnia

// OfType

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

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

// nums = { 1, 2, 3 }

Składnia zapytania

// Not applicable.

ToArray

Konwertuje kolekcję na tablicę.

Metoda Składnia

// ToArray

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

int[] array = numbers.ToArray();

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

Składnia zapytania

// Not applicable.

Notować

Konwertuje kolekcję na listę.

Metoda Składnia

// ToList

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

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

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

Składnia zapytania

// Not applicable.

ToDictionary

Umieszcza elementy w słowniku na podstawie funkcji selektora klawiszy.

Metoda Składnia

// ToDictionary

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

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

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

Składnia zapytania

// Not applicable.

Operacje agregacyjne

Operacje agregacji obliczają pojedynczą wartość ze zbioru wartości.

Agregat

Wykonuje niestandardową operację agregacji wartości kolekcji.

Metoda Składnia

// Aggregate

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

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

// product = 120

Składnia zapytania

// Not applicable.

Średni

Oblicza średnią wartość zbioru wartości.

Metoda Składnia

// Average

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

var average = numbers.Average();

// average = 3

Składnia zapytania

// Not applicable.

Liczyć

Liczy elementy w kolekcji, opcjonalnie tylko te elementy, które spełniają funkcję predykatu.

Metoda Składnia

// Count

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

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

// count = 2

Składnia zapytania

// Not applicable.

LongCount

Liczy elementy w dużej kolekcji, opcjonalnie tylko te elementy, które spełniają funkcję predykatu.

Metoda Składnia

// LongCount

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

long count = numbers.LongCount();

// count = 10

Składnia zapytania

// Not applicable.

Max

Określa maksymalną wartość w kolekcji. Zgłasza wyjątek, jeśli kolekcja jest pusta.

Metoda Składnia

// Max

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

var max = numbers.Max();

// max = 5

Składnia zapytania

// Not applicable.

Min

Określa minimalną wartość w kolekcji. Zgłasza wyjątek, jeśli kolekcja jest pusta.

Metoda Składnia

// Min

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

var min = numbers.Min();

// min = 1

Składnia zapytania

// Not applicable.

Min- / MaxOrDefault

W przeciwieństwie do innych rozszerzeń LinQ Min() i Max() nie mają przeciążenia bez wyjątków. W związku z tym IEnumerable musi być sprawdzony dla Any() przed wywołaniem Min() lub Max()

// Max

var numbers = new int[] { };

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

// max = 0

Suma

Oblicza sumę wartości w kolekcji.

Metoda Składnia

// Sum

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

var sum = numbers.Sum();

// sum = 15

Składnia zapytania

// Not applicable.

Operacje kwantyfikatora

Operacje kwantyfikatora zwracają wartość logiczną, która wskazuje, czy niektóre lub wszystkie elementy w sekwencji spełniają warunek.

Wszystko

Określa, czy wszystkie elementy w sekwencji spełniają warunek.

Metoda Składnia

// All

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

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

// areLessThan10 = true

Składnia zapytania

// Not applicable.

Każdy

Określa, czy którykolwiek element w sekwencji spełnia warunek.

Metoda Składnia

// Any

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

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

// anyOneIsEven = true

Składnia zapytania

// Not applicable.

Zawiera

Określa, czy sekwencja zawiera określony element.

Metoda Składnia

// Contains

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

bool appears = numbers.Contains(10);

// appears = false

Składnia zapytania

// Not applicable.

Grupowanie operacji

Grupowanie odnosi się do operacji umieszczania danych w grupach, aby elementy w każdej grupie miały wspólny atrybut.

Grupuj według

Grupuje elementy, które mają wspólny atrybut.

Metoda Składnia

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

Składnia zapytania

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

ToLookup

Wstawia elementy do słownika jeden do wielu na podstawie funkcji wyboru klucza.

Metoda Składnia

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

Składnia zapytania

// Not applicable.

Operacje partycji

Partycjonowanie odnosi się do operacji dzielenia sekwencji wejściowej na dwie sekcje, bez zmiany kolejności elementów, a następnie zwracania jednej z sekcji.

Pominąć

Pomija elementy do określonej pozycji w sekwencji.

Metoda Składnia

// Skip

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

var skipped = numbers.Skip(3);

// skipped = { 4, 5 }

Składnia zapytania

// Not applicable.

SkipWhile

Pomija elementy oparte na funkcji predykatu, dopóki element nie spełni warunku.

Metoda Składnia

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

Składnia zapytania

// Not applicable.

Brać

Podnosi elementy do określonej pozycji w sekwencji.

Metoda Składnia

// Take

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

var taken = numbers.Take(3);

// taken = { 1, 2, 3 }

Składnia zapytania

// Not applicable.

TakeWhile

Pobiera elementy oparte na funkcji predykatu, dopóki element nie spełni warunku.

Metoda Składnia

// TakeWhile

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

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

// takeLeadingOdds = { 1, 3, 5 }

Składnia zapytania

// Not applicable.

Operacje generacji

Generowanie odnosi się do tworzenia nowej sekwencji wartości.

DefaultIfEmpty

Zastępuje pustą kolekcję kolekcją singletonów o wartości domyślnej.

Metoda Składnia

// DefaultIfEmpty

var nums = new int[0];

var numbers = nums.DefaultIfEmpty();

// numbers = { 0 }

Składnia zapytania

// Not applicable.

Pusty

Zwraca pustą kolekcję.

Metoda Składnia

// Empty

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

// empty = IEnumerable<string> { }

Składnia zapytania

// Not applicable.

Zasięg

Generuje kolekcję zawierającą sekwencję liczb.

Metoda Składnia

// Range

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

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

Składnia zapytania

// Not applicable.

Powtarzać

Generuje kolekcję, która zawiera jedną powtarzaną wartość.

Metoda Składnia

// Repeat

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

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

Składnia zapytania

// Not applicable.

Ustaw operacje

Operacje ustawiania odnoszą się do zapytań, które dają zestaw wyników oparty na obecności lub braku równoważnych elementów w tych samych lub osobnych kolekcjach (lub zestawach).

Odrębny

Usuwa zduplikowane wartości z kolekcji.

Metoda Składnia

// Distinct

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

var distinct = numbers.Distinct();

// distinct = { 1, 2, 3 }

Składnia zapytania

// Not applicable.

Z wyjątkiem

Zwraca ustawioną różnicę, co oznacza elementy jednej kolekcji, które nie pojawiają się w drugiej kolekcji.

Metoda Składnia

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

Składnia zapytania

// Not applicable.

Krzyżować

Zwraca ustawione skrzyżowanie, co oznacza elementy występujące w każdej z dwóch kolekcji.

Metoda Składnia

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

Składnia zapytania

// Not applicable.

Unia

Zwraca zestaw unii, co oznacza unikalne elementy, które pojawiają się w jednej z dwóch kolekcji.

Metoda Składnia

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

Składnia zapytania

// Not applicable.

Operacje na rzecz równości

Dwie sekwencje, których odpowiadające elementy są równe i które mają taką samą liczbę elementów, uważa się za równe.

SequenceEqual

Określa, czy dwie sekwencje są równe, porównując elementy w parach.

Metoda Składnia

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

Składnia zapytania

// Not Applicable.

Operacje na elementach

Operacje na elementach zwracają pojedynczy, określony element z sekwencji.

ElementAt

Zwraca element o określonym indeksie w kolekcji.

Metoda Składnia

// ElementAt

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

var str = strings.ElementAt(2);

// str = "two"

Składnia zapytania

// Not Applicable.

ElementAtOrDefault

Zwraca element pod określonym indeksem w kolekcji lub wartością domyślną, jeśli indeks jest poza zakresem.

Metoda Składnia

// ElementAtOrDefault

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

var str = strings.ElementAtOrDefault(10);

// str = null

Składnia zapytania

// Not Applicable.

Pierwszy

Zwraca pierwszy element kolekcji lub pierwszy element spełniający warunek.

Metoda Składnia

// First

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

var first = strings.First();

// first = 1

Składnia zapytania

// Not Applicable.

FirstOrDefault

Zwraca pierwszy element kolekcji lub pierwszy element spełniający warunek. Zwraca wartość domyślną, jeśli taki element nie istnieje.

Metoda Składnia

// FirstOrDefault

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

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

// firstGreaterThanTen = 0

Składnia zapytania

// Not Applicable.

Ostatni, ubiegły, zeszły

Zwraca ostatni element kolekcji lub ostatni element spełniający warunek.

Metoda Składnia

// Last

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

var last = strings.Last();

// last = 5

Składnia zapytania

// Not Applicable.

LastOrDefault

Zwraca ostatni element kolekcji lub ostatni element spełniający warunek. Zwraca wartość domyślną, jeśli taki element nie istnieje.

Metoda Składnia

// LastOrDefault

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

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

// lastGreaterThanTen = 0

Składnia zapytania

// Not Applicable.

Pojedynczy

Zwraca jedyny element kolekcji lub jedyny element spełniający warunek.

Metoda Składnia

// Single

var numbers = new int[] { 1 };

var single = strings.Single();

// single = 1

Składnia zapytania

// Not Applicable.

SingleOrDefault

Zwraca jedyny element kolekcji lub jedyny element spełniający warunek. Zwraca wartość domyślną, jeśli taki element nie istnieje lub kolekcja nie zawiera dokładnie jednego elementu.

Metoda Składnia

// SingleOrDefault

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

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

// singleGreaterThanFour = 5

Składnia zapytania

// Not Applicable.