Using system linq c что это
Перейти к содержимому

Using system linq c что это

  • автор:

LINQ

LINQ (Language-Integrated Query) представляет простой и удобный язык запросов к источнику данных. В качестве источника данных может выступать объект, реализующий интерфейс IEnumerable (например, стандартные коллекции, массивы), набор данных DataSet, документ XML. Но вне зависимости от типа источника LINQ позволяет применить ко всем один и тот же подход для выборки данных.

Существует несколько разновидностей LINQ:

  • LINQ to Objects : применяется для работы с массивами и коллекциями
  • LINQ to Entities : используется при обращении к базам данных через технологию Entity Framework
  • LINQ to XML : применяется при работе с файлами XML
  • LINQ to DataSet : применяется при работе с объектом DataSet
  • Parallel LINQ (PLINQ) : используется для выполнения параллельных запросов

В этой главе речь пойдет прежде всего о LINQ to Objects , но в последующих материалах также будут затронуты и другие разновидности LINQ. Основная часть функциональности LINQ сосредоточена в пространстве имен System.LINQ . В проектах под .NET 6 данное пространство имен подключается по умолчанию.

В чем же удобство LINQ? Посмотрим на простейшем примере. Выберем из массива строки, которые начинаются на определенную букву, например, букву «T», и отсортируем полученный список:

string[] people = < "Tom", "Bob", "Sam", "Tim", "Tomas", "Bill" >; // создаем новый список для результатов var selectedPeople = new List(); // проходим по массиву foreach (string person in people) < // если строка начинается на букву T, добавляем в список if (person.ToUpper().StartsWith("T")) selectedPeople.Add(person); >// сортируем список selectedPeople.Sort(); foreach (string person in selectedPeople) Console.WriteLine(person);

Для отфильтрованных строк создается специальный список. Затем в цикле проходим по всем элементам массива и, если они соответствуют условию (начинаются на букву T), то добавляем их в этот список. Затем сортируем список по возрастанию. И в конце элементы полученного списка выводим на консоль:

Tim Tom Tomas

Хотя подобный подход вполне работает, однако LINQ позволяет значительно сократить код с помощью интуитивно понятного и краткого синтаксиса.

Для работы с колекциями можно использовать два способа:

  • Операторы запросов LINQ
  • Методы расширений LINQ Рассмотрим оба способа

Операторы запросов LINQ

Операторы запросов LINQ в каком-то роде частично напоминают синтаксис запросов SQL, поэтому если вы работали когда-нибудь с sql-запросами, то будет проще понять общую концепцию. Итак, изменим предыдущий пример, применив операторы запросов LINQ:

string[] people = < "Tom", "Bob", "Sam", "Tim", "Tomas", "Bill" >; // создаем новый список для результатов var selectedPeople = from p in people // передаем каждый элемент из people в переменную p where p.ToUpper().StartsWith("T") //фильтрация по критерию orderby p // упорядочиваем по возрастанию select p; // выбираем объект в создаваемую коллекцию foreach (string person in selectedPeople) Console.WriteLine(person);

Прежде всего, как мы видим, код стал меньше и проще, а результат будет тем же. В принципе все выражение можно было бы записать в одну строку:

var selectedPeople = from p in people where p.ToUpper().StartsWith("T") orderby p select p;

Но для более понятной логической разбивки я поместил каждое отдельное подвыражение на отдельной строке. Простейшее определение запроса LINQ выглядит следующим образом:

from переменная in набор_объектов select переменная;

Итак, что делает этот запрос LINQ? Выражение from p in people проходит по всем элементам массива people и определяет каждый элемент как p . Используя переменную p мы можем проводить над ней разные операции. Несмотря на то, что мы не указываем тип переменной p , выражения LINQ являются строго типизированными. То есть среда автоматически распознает, что набор people состоит из объектов string, поэтому переменная p будет рассматриваться в качестве строки. Далее с помощью оператора where проводится фильтрация объектов, и если объект соответствует критерию (в данном случае начальная буква должна быть «T»), то этот объект передается дальше. Оператор orderby упорядочивает по возрастанию, то есть сортирует выбранные объекты. Оператор select передает выбранные значения в результирующую выборку, которая возвращается LINQ-выражением. В данном случае результатом выражения LINQ является объект IEnumerable . Нередко результирующая выборка определяется с помощью ключевого слова var , тогда компилятор на этапе компиляции сам выводит тип.

Методы расширения LINQ

Кроме стандартного синтаксиса from .. in .. select для создания запроса LINQ мы можем применять специальные методы расширения, которые определены для интерфейса IEnumerable . Как правило, эти методы реализуют ту же функциональность, что и операторы LINQ типа where или orderby . Например:

string[] people = < "Tom", "Bob", "Sam", "Tim", "Tomas", "Bill" >; var selectedPeople = people.Where(p => p.ToUpper().StartsWith("T")).OrderBy(p => p); foreach (string person in selectedPeople) Console.WriteLine(person);

Запрос people.Where(p=>p.ToUpper().StartsWith(«T»)).OrderBy(p => p) будет аналогичен предыдущему. Он состоит из цепочки методов Where и OrderBy. В качестве аргумента эти методы принимают делегат или лямбда-выражение. И хотя ряд действий мы можем реализовать как с помощью операторов запросов LINQ, так и с помощью методов расширений LINQ, но не каждый метод расширения имеет аналог среди операторов LINQ. И в этом случае можно сочетать оба подхода. Например, используем стандартный синтаксис linq и метод расширения Count(), который возвращает количество элементов в выборке:

int number = (from p in people where p.ToUpper().StartsWith("T") select p).Count(); Console.WriteLine(number); // 3

Список используемых методов расширения LINQ

  • Select : определяет проекцию выбранных значений
  • Where : определяет фильтр выборки
  • OrderBy : упорядочивает элементы по возрастанию
  • OrderByDescending : упорядочивает элементы по убыванию
  • ThenBy : задает дополнительные критерии для упорядочивания элементов возрастанию
  • ThenByDescending : задает дополнительные критерии для упорядочивания элементов по убыванию
  • Join : соединяет две коллекции по определенному признаку
  • Aggregate : применяет к элементам последовательности агрегатную функцию, которая сводит их к одному объекту
  • GroupBy : группирует элементы по ключу
  • ToLookup : группирует элементы по ключу, при этом все элементы добавляются в словарь
  • GroupJoin : выполняет одновременно соединение коллекций и группировку элементов по ключу
  • Reverse : располагает элементы в обратном порядке
  • All : определяет, все ли элементы коллекции удовлятворяют определенному условию
  • Any : определяет, удовлетворяет хотя бы один элемент коллекции определенному условию
  • Contains : определяет, содержит ли коллекция определенный элемент
  • Distinct : удаляет дублирующиеся элементы из коллекции
  • Except : возвращает разность двух коллекцию, то есть те элементы, которые создаются только в одной коллекции
  • Union : объединяет две однородные коллекции
  • Intersect : возвращает пересечение двух коллекций, то есть те элементы, которые встречаются в обоих коллекциях
  • Count : подсчитывает количество элементов коллекции, которые удовлетворяют определенному условию
  • Sum : подсчитывает сумму числовых значений в коллекции
  • Average : подсчитывает cреднее значение числовых значений в коллекции
  • Min : находит минимальное значение
  • Max : находит максимальное значение
  • Take : выбирает определенное количество элементов
  • Skip : пропускает определенное количество элементов
  • TakeWhile : возвращает цепочку элементов последовательности, до тех пор, пока условие истинно
  • SkipWhile : пропускает элементы в последовательности, пока они удовлетворяют заданному условию, и затем возвращает оставшиеся элементы
  • Concat : объединяет две коллекции
  • Zip : объединяет две коллекции в соответствии с определенным условием
  • First : выбирает первый элемент коллекции
  • FirstOrDefault : выбирает первый элемент коллекции или возвращает значение по умолчанию
  • Single : выбирает единственный элемент коллекции, если коллекция содержит больше или меньше одного элемента, то генерируется исключение
  • SingleOrDefault : выбирает единственный элемент коллекции. Если коллекция пуста, возвращает значение по умолчанию. Если в коллекции больше одного элемента, генерирует исключение
  • ElementAt : выбирает элемент последовательности по определенному индексу
  • ElementAtOrDefault : выбирает элемент коллекции по определенному индексу или возвращает значение по умолчанию, если индекс вне допустимого диапазона
  • Last : выбирает последний элемент коллекции
  • LastOrDefault : выбирает последний элемент коллекции или возвращает значение по умолчанию

Шпаргалка по LINQ и SQL

Шпаргалка по LINQ и SQL

Последовательность, — любая коллекция, реализующая интерфейс IEnumerable<> или IQueryable<>. Оператор запроса — метод, преобразующий последовательность. Запрос — выражение, которое преобразует последовательность с помощью операторов запроса.

Синтаксис
LINQ поддерживает два вида синтаксиса: синтаксис запросов и синтаксис методов
Синтаксис запросов:

int[] MyArray = < -1, 2, 3, -4 >; var res = from n in MyArray where n > 0 select n; // 2, 3 

Такой синтаксис всегда должен начинаться с from in и заканчиваться select или group. Синтаксис методов:

int[] array = < -5, 2, 3, -11 >; var res = array.Where(n => n > 0); // 2, 3 

Все стандартные методы реализованы как расширяющие, большинство из них принимает в параметр лямбда-выражение или делегат.
Методы можно применять один за другим:

int[] msv = < -1, 2, 3, -4, 0, 2, 8, 9, 3 >; var res = msv.Where(n => n > 0 && n % 2 == 0).Select(n => n+1).Take(3).Sum(); // 15 

Оба вида синтаксиса можно использовать вместе.

Лямбда-выражения

Лямбда-выражения — это специальный синтаксис для сокращённого объявления анонимных методов.
Пример синтаксиса: n => n * n Это выражение принимает один параметр (n) и возвращает n * n.
Пример использования:

int[] msv = < 1, 2, 3 >; var res = msv.Select(n => n * n); // 1, 4, 9

=> — лямбда оператор, который читается как «переходит в».
Слева от лямбда оператора стоят параметры ввода, справа — выражение
Это лямбда-выражение эквивалентно такому: n => < return n * n; >и такому delegate(int n) < return n * n; >
Стандартные операторы запроса используют обобщенные делегаты Func, например Func соответствует лямбда-выражению int => bool, а Func — (string, string) => int
Возвращаемое значение Func всегда указывается в качестве последнего аргумента.
В лямбда-выражения можно использовать внешние переменные:

int[] msv = < 1, 2, 3 >; int mult = 10; var res = msv.Select(n => n * mult); foreach (int i in res) Console.WriteLine(i); // 10, 20, 30 

Отложенное выполнение

Большая часть операторов запроса выполняется не при конструировании, а только при переборе элементов.
Пример:

int[] msv = < 1, 2, 3 >; int mult = 2; var res = msv.Select(n => n * mult); // Здесь запрос еще не выполняется mult = 20; foreach (int i in res) Console.WriteLine(i); // Он выполняется здесь // 20, 40, 60 

Это называется отложенным или ленивым выполнением, оно характерно для всех операторов запроса, кроме операторов, возвращающих один элемент (First) или значение (Sum), а также для операторов преобразования типа (ToArray, ToList)

Расширяющие методы

Поскольку все операторы запроса реализованы в виде расширяющих методов, можно легко добавить собственные
Несколько примеров расширяющих методов для LINQ. Метод, обратный методу Where, возвращает последовательность, элементы которой не удовлетворяют предикату

public static IEnumerable WhereNot(this IEnumerable source, Func predicat) < foreach (TSource element in source) < if (predicat(element) == false) yield return element; >> //Оператор yield return возвращает один элемент коллекции и перемещает итератор дальше, yield break прекращает итерацию. // использование метода int[] msv = < 1, 2, 3, 4, 0 >; var res = msv.WhereNot(n => n > 2); // 1, 2, 0 

Метод, возвращающий последовательность от и до определенных индексов

public static IEnumerable TakeFromTo(this IEnumerable source, int from, int to) < int iterator = -1; foreach (TSource element in source) < iterator++; if (iterator >= from && iterator > // пример использования int[] msv = < 1, 2, 3, 4, 5, 6 >; var res = msv.TakeFromTo(1, 4); // 2, 3, 4, 5 
public static IEnumerable QuickSort(this IEnumerable source) where T : IComparable  < if (!source.Any()) return source; var first = source.First(); return source.GroupBy(i =>i.CompareTo(first)).OrderBy(g => g.Key).SelectMany(g => g.Key == 0 ? g : QuickSort(g)); > 

Определение минимального и максимального числа в массиве

// using System.Linq; int min = a.Min(); int max = a.Max(); 

Определение суммы чисел в массиве

int sum = a.Sum();

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

// using System.Linq; int[] reversedArray = a.Reverse().ToArray(); 

Возвращает различающиеся элементы последовательности

int[] uniqArray = a.Distinct().ToArray();

Возвращает только те элементы последовательности first, которых нет в последовательности second

int[] arr = first.Where(x => !second.Contains(x)).ToArray();

Находит пересечение множеств, представленных двумя последовательностями

int[] arr = first.Intersect(second).ToArray();

Проецирует матрицу в последовательность

var tmp = new List(matrix.GetLength(0)*matrix.GetLength(1)); foreach (int x in matrix) tmp.Add(x); int[] arr = tmp.ToArray(); 

Находит объединение множеств, представленных двумя последовательностями

int[] arr = first.Union(second).ToArray();

SQL

SELECT

SELECT — оператор DML языка SQL, возвращающий набор данных (выборку) из базы данных, удовлетворяющих заданному условию.

вернёт все столбцы всех строк данной таблицы. Для той же таблицы запрос

SELECT * FROM T;

вернёт те же строки, что и первый, однако результат будет отсортирован в обратном порядке (Z-A) из-за использования ключевого слова ORDER BY с полем C1 в качестве поля сортировки

SELECT * FROM T ORDER BY C1 DESC;

DESC – обратный порядок (последний элемент будет 1 в списке)

ASC – сортировать от первого элемента к последнему (1 элемент будет первым в списке)

Отбирает все строки где поле column_name равен одному из перечисленных значений value1,value2,…

SELECT * FROM TABLE_NAME WHERE column_name IN (value1,value2. ) 

INSERT

Используя перечисление значений, с указанием столбцов:

INSERT INTO ([, . ]) VALUES (. )

Используя перечисление значений, без указания столбцов:

INSERT INTO VALUES (. )
INSERT INTO SELECT . FROM // В этом случае, в таблицу может вставиться более одной записи. Если в таблице есть // другие поля требующие заполнения, но не указанные в операторе insert, для них будет // установлено значение по умолчанию, либо null, если значение по умолчанию не указано. 
INSERT INTO EMPSAMP (NAME, SALARY, DEPTNO, LEVEL) VALUES(’Mary Smith’, 35000.00, 11, ’Associate’)

UPDATE

UPDATE per­sons SET street = 'Nis­sesti­en 67', ci­ty = 'Sand­nes' WHERE lastname = 'Tjes­sem' AND firs­tna­me = 'Ja­kob'

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *