linq
Стандартные операторы запросов

замечания

Операции конкатенации

Конкатенация относится к операции добавления одной последовательности в другую.

Concat

Конкатенация двух последовательностей для формирования одной последовательности.

Синтаксис метода

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

Синтаксис запроса

// Not applicable.

Операции фильтрации

Фильтрация относится к операциям ограничения набора результатов, содержащего только те элементы, которые удовлетворяют заданному условию.

куда

Выбирает значения, основанные на функции предиката.

Синтаксис метода

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

Синтаксис запроса

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

Выбирает значения, в зависимости от их способности быть нажатыми для указанного типа.

Синтаксис метода

// OfType

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

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

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

Синтаксис запроса

// Not applicable.

Присоединиться к

Соединение двух источников данных - это объединение объектов в один источник данных с объектами, которые имеют общий атрибут в другом источнике данных.

Присоединиться

Объединение двух последовательностей основано на функциях выбора ключа и извлекает пары значений.

Синтаксис метода

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

Синтаксис запроса

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

Объединение двух последовательностей на основе функций селектора ключей и группирует итоговые совпадения для каждого элемента.

Синтаксис метода

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

Синтаксис запроса

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

застежка - молния

Применяет указанную функцию к соответствующим элементам двух последовательностей, создавая последовательность результатов.

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 |

Проекционные операции

Проекция относится к операциям преобразования объекта в новую форму.

Выбрать

Значения проектов, основанные на функции преобразования.

Синтаксис метода

// Select

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

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

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

Синтаксис запроса

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

Проекты последовательностей значений, которые основаны на функции преобразования, а затем сглаживают их в одну последовательность.

Синтаксис метода

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

Синтаксис запроса

// multiples from

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

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

Операции сортировки

Операция сортировки упорядочивает элементы последовательности, основанные на одном или нескольких атрибутах.

Сортировать по

Сортирует значения в порядке возрастания.

Синтаксис метода

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

Синтаксис запроса

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

Сортирует значения в порядке убывания.

Синтаксис метода

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

Синтаксис запроса

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

Выполняет вторичный сортировку в порядке возрастания.

Синтаксис метода

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

Синтаксис запроса

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

Выполняет вторичный сортировку в порядке убывания.

Синтаксис метода

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

Синтаксис запроса

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

Задний ход

Изменяет порядок элементов в коллекции.

Синтаксис метода

// Reverse

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

var reversed = numbers.Reverse();

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

Синтаксис запроса

// Not applicable.

Операции конверсии

Операции преобразования изменяют тип входных объектов.

AsEnumerable

Возвращает ввод, введенный как IEnumerable.

Синтаксис метода

// AsEnumerable

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

var nums = numbers.AsEnumerable();

// nums: static type is IEnumerable<int>

Синтаксис запроса

// Not applicable.

AsQueryable

Преобразует IEnumerable в IQueryable.

Синтаксис метода

// AsQueryable

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

var nums = numbers.AsQueryable();

// nums: static type is IQueryable<int>

Синтаксис запроса

// Not applicable.

В ролях

Переводит элементы коллекции в заданный тип.

Синтаксис метода

// Cast

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

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

// nums: static type is IEnumerable<int>

Синтаксис запроса

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

Значения фильтров, в зависимости от их способности быть отлиты к указанному типу.

Синтаксис метода

// OfType

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

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

// nums = { 1, 2, 3 }

Синтаксис запроса

// Not applicable.

ToArray

Преобразует коллекцию в массив.

Синтаксис метода

// ToArray

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

int[] array = numbers.ToArray();

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

Синтаксис запроса

// Not applicable.

К списку

Преобразует коллекцию в список.

Синтаксис метода

// ToList

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

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

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

Синтаксис запроса

// Not applicable.

ToDictionary

Вставляет элементы в словарь на основе функции выбора ключа.

Синтаксис метода

// ToDictionary

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

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

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

Синтаксис запроса

// Not applicable.

Агрегирование

Операции агрегирования вычисляют одно значение из набора значений.

заполнитель

Выполняет настраиваемую операцию агрегации по значениям коллекции.

Синтаксис метода

// Aggregate

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

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

// product = 120

Синтаксис запроса

// Not applicable.

Средний

Вычисляет среднее значение набора значений.

Синтаксис метода

// Average

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

var average = numbers.Average();

// average = 3

Синтаксис запроса

// Not applicable.

подсчитывать

Подсчитывает элементы в коллекции, необязательно только те элементы, которые удовлетворяют предикатной функции.

Синтаксис метода

// Count

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

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

// count = 2

Синтаксис запроса

// Not applicable.

LongCount

Подсчитывает элементы в большой коллекции, необязательно только те элементы, которые удовлетворяют предикатной функции.

Синтаксис метода

// LongCount

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

long count = numbers.LongCount();

// count = 10

Синтаксис запроса

// Not applicable.

Максимум

Определяет максимальное значение в коллекции. Выдает исключение, если коллекция пуста.

Синтаксис метода

// Max

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

var max = numbers.Max();

// max = 5

Синтаксис запроса

// Not applicable.

Min

Определяет минимальное значение в коллекции. Выдает исключение, если коллекция пуста.

Синтаксис метода

// Min

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

var min = numbers.Min();

// min = 1

Синтаксис запроса

// Not applicable.

Мин- / MaxOrDefault

В отличие от других расширений LinQ Min() и Max() не имеют перегрузки без исключений. Для этого IEnumerable необходимо проверить для Any() перед вызовом Min() или Max()

// Max

var numbers = new int[] { };

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

// max = 0

сумма

Вычисляет сумму значений в коллекции.

Синтаксис метода

// Sum

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

var sum = numbers.Sum();

// sum = 15

Синтаксис запроса

// Not applicable.

Операции квантификатора

Операции квантора возвращают логическое значение, указывающее, удовлетворяют ли некоторые или все элементы в последовательности условию.

Все

Определяет, удовлетворяют ли все элементы в последовательности условию.

Синтаксис метода

// All

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

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

// areLessThan10 = true

Синтаксис запроса

// Not applicable.

любой

Определяет, удовлетворяют ли любые элементы в последовательности условию.

Синтаксис метода

// Any

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

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

// anyOneIsEven = true

Синтаксис запроса

// Not applicable.

Содержит

Определяет, содержит ли последовательность указанный элемент.

Синтаксис метода

// Contains

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

bool appears = numbers.Contains(10);

// appears = false

Синтаксис запроса

// Not applicable.

Группировка операций

Группирование относится к операциям ввода данных в группы, так что элементы в каждой группе имеют общий атрибут.

Группа по

Элементы групп, которые имеют общий атрибут.

Синтаксис метода

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

Синтаксис запроса

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

Вставляет элементы в словарь «один-ко-многим», основанный на функции выбора ключа.

Синтаксис метода

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

Синтаксис запроса

// Not applicable.

Операции с разделами

Разделение относится к операциям деления входной последовательности на две части без переупорядочения элементов, а затем возвращает один из разделов.

Пропускать

Пропускает элементы до заданной позиции в последовательности.

Синтаксис метода

// Skip

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

var skipped = numbers.Skip(3);

// skipped = { 4, 5 }

Синтаксис запроса

// Not applicable.

SkipWhile

Пропускает элементы на основе функции предиката, пока элемент не удовлетворяет условию.

Синтаксис метода

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

Синтаксис запроса

// Not applicable.

принимать

Забирает элементы в определенную позицию в последовательности.

Синтаксис метода

// Take

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

var taken = numbers.Take(3);

// taken = { 1, 2, 3 }

Синтаксис запроса

// Not applicable.

TakeWhile

Принимает элементы, основанные на функции предиката, пока элемент не удовлетворяет условию.

Синтаксис метода

// TakeWhile

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

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

// takeLeadingOdds = { 1, 3, 5 }

Синтаксис запроса

// Not applicable.

Операции генерации

Генерация относится к созданию новой последовательности значений.

DefaultIfEmpty

Заменяет пустую коллекцию выделенной одноэлементной коллекцией по умолчанию.

Синтаксис метода

// DefaultIfEmpty

var nums = new int[0];

var numbers = nums.DefaultIfEmpty();

// numbers = { 0 }

Синтаксис запроса

// Not applicable.

пустой

Возвращает пустую коллекцию.

Синтаксис метода

// Empty

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

// empty = IEnumerable<string> { }

Синтаксис запроса

// Not applicable.

Спектр

Создает коллекцию, содержащую последовательность чисел.

Синтаксис метода

// Range

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

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

Синтаксис запроса

// Not applicable.

Повторение

Создает коллекцию, содержащую одно повторяющееся значение.

Синтаксис метода

// Repeat

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

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

Синтаксис запроса

// Not applicable.

Установить операции

Операции установки относятся к операциям запроса, которые создают набор результатов, основанный на наличии или отсутствии эквивалентных элементов в пределах того же или отдельных коллекций (или наборов).

отчетливый

Удаляет повторяющиеся значения из коллекции.

Синтаксис метода

// Distinct

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

var distinct = numbers.Distinct();

// distinct = { 1, 2, 3 }

Синтаксис запроса

// Not applicable.

Кроме

Возвращает заданное различие, что означает элементы одной коллекции, которые не отображаются во второй коллекции.

Синтаксис метода

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

Синтаксис запроса

// Not applicable.

пересекаться

Возвращает заданное пересечение, что означает элементы, которые появляются в каждой из двух коллекций.

Синтаксис метода

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

Синтаксис запроса

// Not applicable.

союз

Возвращает объединение единиц, что означает уникальные элементы, которые появляются в любом из двух коллекций.

Синтаксис метода

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

Синтаксис запроса

// Not applicable.

Операции по обеспечению равенства

Две последовательности, соответствующие элементы которых равны и которые имеют одинаковое количество элементов, считаются равными.

SequenceEqual

Определяет, равны ли две последовательности, сравнивая элементы по-парному.

Синтаксис метода

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

Синтаксис запроса

// Not Applicable.

Элементные операции

Операции элементов возвращают один, определенный элемент из последовательности.

ElementAt

Возвращает элемент по указанному индексу в коллекции.

Синтаксис метода

// ElementAt

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

var str = strings.ElementAt(2);

// str = "two"

Синтаксис запроса

// Not Applicable.

ElementAtOrDefault

Возвращает элемент по указанному индексу в коллекции или по умолчанию, если индекс находится вне допустимого диапазона.

Синтаксис метода

// ElementAtOrDefault

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

var str = strings.ElementAtOrDefault(10);

// str = null

Синтаксис запроса

// Not Applicable.

Первый

Возвращает первый элемент коллекции или первый элемент, который удовлетворяет условию.

Синтаксис метода

// First

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

var first = strings.First();

// first = 1

Синтаксис запроса

// Not Applicable.

FirstOrDefault

Возвращает первый элемент коллекции или первый элемент, который удовлетворяет условию. Возвращает значение по умолчанию, если такой элемент не существует.

Синтаксис метода

// FirstOrDefault

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

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

// firstGreaterThanTen = 0

Синтаксис запроса

// Not Applicable.

Прошлой

Возвращает последний элемент коллекции или последний элемент, удовлетворяющий условию.

Синтаксис метода

// Last

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

var last = strings.Last();

// last = 5

Синтаксис запроса

// Not Applicable.

LastOrDefault

Возвращает последний элемент коллекции или последний элемент, удовлетворяющий условию. Возвращает значение по умолчанию, если такой элемент не существует.

Синтаксис метода

// LastOrDefault

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

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

// lastGreaterThanTen = 0

Синтаксис запроса

// Not Applicable.

не замужем

Возвращает единственный элемент коллекции или единственный элемент, который удовлетворяет условию.

Синтаксис метода

// Single

var numbers = new int[] { 1 };

var single = strings.Single();

// single = 1

Синтаксис запроса

// Not Applicable.

SingleOrDefault

Возвращает единственный элемент коллекции или единственный элемент, который удовлетворяет условию. Возвращает значение по умолчанию, если такой элемент не существует или коллекция не содержит ровно один элемент.

Синтаксис метода

// SingleOrDefault

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

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

// singleGreaterThanFour = 5

Синтаксис запроса

// Not Applicable.