Ответы на экзамен (987689), страница 16

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

Текст из файла (страница 16)

68.Две разновидности синтаксиса на LINQ

Простейший запрос состоит из одной входной по­следовательности и одного оператора. Например, мы можем применить оператор where к строковому массиву и извлечь те его элементы, длина которых не меньше четырех символов. Поскольку стандартные операторы запроса реали­зованы в виде методов расширения, мы можем вы­звать Where непосредственно ДЛЯ массива names так, словно это метод экземпляра:

IEnumerable<string> filteredNames = names."Where (n => n.Length >= 4);

Большинство операторов запроса принимает лямбда-выражение в качестве аргумента. Лямбда-выражение помогает направить и сформировать запрос. В нашем примере лямбда-выражение выглядит так:

n => п.Length >= 4

Входной аргумент соответствует входному эле­менту. В этом случае входной аргумент n пред­ставляет имя в массиве и имеет тип string. Опера­тор where требует, чтобы лямбда-выражение возвращало значение типа bool. Когда оно истин­но, элемент должен быть включен в выходную по­следовательность.

Будем называть такие запросы лямбда-запросами

Чтобы строить более сложные запросы, вы добав­ляете новые операторы, образуя цепочку. Напри­мер, в следующем запросе из массива извлекаются все строки с буквой "а", после чего они сортиру­ются по длине и переводятся в верхний регистр:

string[] names = {"Tom","Dick","Harry","Mary","Jay" }; IEnumerable<string> query = names.Where (n => n.Contains ("a")) .OrderBy (n => n.Length) .Select (n => n.ToUpper());

foreach (string name in query)

Console.Write (name + "|");

//Результат: JAY|MARY|HARRY|

Вот как выглядит тот же запрос в соответст­вии с синтаксисом, облегчающим его восприятие:

string[] names = {

"Tom","Dick","Harry","Mary","Jay" };

IEnumerable<string> query =

from n in names

where n.Contains ("a") // Фильтровать эле­менты

orderby n.Length // Сортировать эле­менты

select n.ToUpper(); // Проецировать каж­дый элемент

foreach (string name in query)

Console.Write (name + "/");

// Результат: JAY/MARY/HARRY/

Запрос с синтаксисом, облегчающим восприятие, всегда начинается с конструкции from и заканчи­вается конструкцией либо select, либо group. Конструкция from объявляет переменную итера­ции (в данном случае n). Вы можете считать, что она используется для перебора элементов входной коллекции, аналогично оператору foreach.

Компилятор обрабатывает запросы с синтаксисом, облегчающим восприятие, переводя их в лямбда-синтаксис. Фактически это означает, что все, написанное вами в соответствии с синтакси­сом, облегчающим восприятие, могло быть написано и с соблюдением лямбда-синтаксиса. Запрос из наше­го примера транслируется в следующий код:

IEnumerable<string> query = names .Where (n => n.Contains ("a")).OrderBy (n => n.Length).Select (n => n.ToUpper());

Затем операторы Where, OrderBy и Select будут откомпилированы по тем же правилам, что и за­просы, изначально написанные с соблюдением лямбда-синтаксиса.

Если оператор запроса не поддерживается синтак­сисом, облегчающим восприятие, вы можете ком­бинировать этот синтаксис с лямбда-синтаксисом. Единственное требование, которое при этом вы­двигается, — каждая составляющая "понятного" синтаксиса должна быть полной (то есть начинать­ся с конструкции from и заканчиваться конструк­цией select ИЛИ group).

Например:

int count =

(

from name in names

where n.Contains ("a")

select name

).Count();

Бывают ситуации, в которых запросы со смешан­ным синтаксисом оказываются самыми эффектив­ными в терминах функциональности и простоты. Избегайте оказывать предпочтение какому-то од­ному из двух вариантов синтаксиса. В противном случае вы не сможете уверенно и безошибочно пи­сать запросы в смешанном синтаксисе!

69.Отложенное выполнение операторов на LINQ

Важной особенностью большинства операторов запроса является тот факт, что они выполняются не тогда, когда сконструированы, а при переборе эле­ментов (то есть когда для соответствующего пере­числителя вызывается метод MoveNext):

var numbers = new List<int>(); numbers.Add (1) ; // Построить запрос

IEnumerable<int> query = numbers.Select (n => n * 10);

numbers.Add (2); // "Незаметно" добавить еще один элемент

foreach (int n in query)

Console.Write (n + "|");

// 10|20|

Дополнительный элемент, который мы "тайком" добавили после конструирования запроса, попадает в результат, потому что ни фильтрация, ни сорти­ровка не происходят, пока не начнет выполняться оператор foreach. Это называется отложенным или "ленивым" выполнением. Отложенное выпол­нение характерно для всех стандартных операто­ров запроса, кроме

∙••••• операторов, возвращающих один элемент или скалярное значение, таких как First или Count;

∙••••• операторов преобразования типа: ToArray, ToList, ToDictionary, ToLookup

Эти операторы приводят к немедленному выпол­нению запроса, потому что у возвращаемых ими результатов нет механизма, который обеспечивал бы отложенное выполнение. Например, метод Count возвращает целое число, которое затем ни­как не "перебирается". Следующий запрос выпол­няется немедленно:

int matches = numbers.Where (n => n < 2).Count(); // 1

Отложенное выполнение играет важную роль, по­тому что оно отделяет конструирование запроса от его выполнения. Это позволяет вам конструиро­вать запрос за несколько шагов, а также делать LINQ-запросы к SQL.

70.Операторы Select, Where, Take, Skip, TakeWhile, SkipWhile

Проецирование

Оператор Select

Синтаксис,облегчающий восприятие

select выражение_проецирования

Описание

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

В следующем коде выбираются названия всех шрифтов, установленных на компьютере (из про­странства имен System. Drawing):

IEnumerable<string> query =

from f in FontFamily.Families

select f.Name;

foreach (string name in query)

Console.WriteLine (name);

В этом примере предложение select преобразует объект FontFamily в его имя. Вот лямбда-эквивалент этого кода:

IEnumerable<string> query = FontFamily.Families.Select (f => f.Name);

Фильтрация

Каким бы методом фильтрации вы ни пользова­лись, вы всегда получите либо то же самое, либо меньшее количество элементов по сравнению с оригинальной последовательностью. Вы никогда не получите больше! Кроме того, элементы на вы­ходе идентичны оригинальным; они никак не пре­образуются.

Оператор Where

Синтаксис,облегчающий восприятие

where булево_выражение

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

Например:

string[] names = {"Tom","Dick","Harry","Mary", "Jay" }; IEnumerable<string> query = names.Where (name => name.EndsWith ("y"));

// Результат: { "Harry", "Mary", "Jay" }

В синтаксисе, облегчающем восприятие, этот за­прос выглядит так:

IEnumerable<string> query =

from n in names

where n.EndsWith("y")

select n;

Конструкция where может появиться в запросе бо­лее одного раза, причем она может чередоваться с конструкцией let:

from n in names

where n.Length > 3

let u = n.ToUpper()

where u.EndsWith ("Y")

select u;

// Результат: { "HARRY", "MARY"}

Для таких операторов действуют стандартные пра­вила относительно области видимости, принятые в С#. Иными словами, вы не можете ссылаться на переменную до ее появления с помощью перемен­ной итерации или конструкции let.

Операторы Take и Skip

Оператор Take возвращает первые n элементов и игнорирует остальные, а оператор skip игнорирует первые n элементов и возвращает остальные. Эти два метода полезны в сочетании, когда вы реали­зуете веб-страницу, позволяющую пользователю просматривать большое количество записей, соот­ветствующих его запросу. Предположим, напри­мер, пользователь ищет в базе данных книги, в на­званиях которых встречается слово "mercury" (ртуть), и таковых оказывается 100 штук.

Следующий запрос возвращает первые 20 названий:

IQueryable<Book> query = dataContext.Books.Where (b => b.Title.Contains("mercury")).OrderBy(b => b.Title).Take (20);

А этот запрос возвращает названия с 21 по 40:

IQueryable<Book> query - dataContext.Books.Where (b => b.Title.Contains("mercury")).OrderBy(b => b.Title).Skip(20).Take(20);

Операторы TakeWhile и SkipWhile

Оператор TakeWhile перебирает элементы входной последовательности и возвращает каждый из них, пока заданный предикат имеет значение true. После этого все остальные элементы игнориру­ются:

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

var takeWhileSmall = numbers.TakeWhile (n => n < 100);

Характеристики

Список файлов ответов (шпаргалок)