СиППО (67-73) (Ответы на все вопросы), страница 2

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

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

Аргумент	Тип
Исходная последовательность	IEnumerable<TSource>
Количество элементов, кото­рые необходимо возвратить или пропустить	int

Оператор 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

Аргумент	Тип
Исходная последовательность	IEnumerable<TSource>
Предикат	TSource => bool

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

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

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

// Результат: { 3, 5, 2 }

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

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

var skipWhileSmall = numbers.SkipWhile (n => n < 100) ;

// Результат: { 234, 4, 1 }

71.Агрегирующие функции на LINQ

Методы агрегирования

Метод	Описание
Count, LongCount	Возвращают количество элементов во входной последовательности, возможно, удовлетво­ряющих заданному предикату
Min, Max	Возвращают наимень­ший и, соответственно, наибольший элемент последовательности
Sum, Average	Вычисляют сумму и среднее арифметиче­ское элементов после­довательности

Операторы Count и LongCount

Аргумент	Тип
Исходная последователь­ность	IEnumerable<TSource>
Предикат (необязательный)	TSource => bool

Оператор Count просто перебирает элементы по­следовательности, возвращая их количество:

int fullCount = new int[] { 5, 6, 7 }.Count(); // 3

Метод Enumerable.Count проверяет, реализует ли входная            последовательность интерфейс ICollection<T>. Если реализует, он просто вызы­вает метод ICollection<T>.Count. В противном случае он перебирает все элементы, увеличивая счетчик.

При необходимости вы можете указать предикат:

int digitCount = "pa55w0rd".Count(с => char.IsDigit(с)); // 3

Оператор LongCount делает то же самое, что и Count, но возвращает 64-битовое целое, что позво­ляет иметь дело с последовательностями из более чем двух миллиардов элементов.

Операторы Min и Мах

Аргумент	Тип
Исходная последовательность	IEnumerable<TSource>
Селектор результата (необя­зательный)	TSource => TResult

Операторы Min и Mах возвращают наименьший и наибольший элементы последовательности:

int[] numbers = { 28, 32, 14 };

int smallest = numbers.Min(); // 14;

int largest = numbers.Max(); // 32;

Если вы укажете выражение-селектор, каждый элемент вначале будет подвергнут проекции:

int smallest = numbers.Max (n => n % 10); // 8;

Выражение-селектор обязательно, если элементы сами по себе не подлежат сравнению, то есть не реализуют интерфейс IComparable<T>.

Операторы Sum и Average

Аргумент	Тип
Исходная последователь­ность	IEnumerable<TSource>
Селектор результата (необязательный)	TSource => TResult

Операторы Sum и Average являются операторами агрегирования и используются аналогично опера­торам Min И мах:

decimal[] numbers = { 3, 4, 8 };

decimal sumTotal = numbers.Sum(); // 15

decimal average = numbers.Average(); //5 (среднееарифметическое)

Следующий код возвращает суммарную длину всех строк массива names:

int combinedLength = names.Sum (s => s.Length); // 19

72.Группировка данных на LINQ

Группирование

Метод	Описание
GroupBy	Разбивает последова­тельность на подпосле­довательности

Оператор GroupBy

Аргумент	Тип
Входная последо­вательность	IEnumerable<TSource>
Селектор ключа	TSource => TKey
Селектор элемента (необязательный)	TSource => TElement
Класс, выполняю­щий сравнение (необязательный)	IEqualityComparer<TKey>

Тип возвращаемого значения:

IEnumerable<IGrouping<TSource,TElement>>

Синтаксис,

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

group выражение_для_элемента by выраже- ние_для_ключа

Описание

Оператор GroupBy реорганизует плоскую входную последовательность в последовательность групп. Например, в следующем коде файлы в каталоге c:\temp группируются по расширению:

string[] files = Directory.GetFiles ("с: Wtemp") ;

IEnumerable<IGrouping<string,string>> query =

files.GroupBy (file => Path.GetExtension (file));

Метод Enumerable.GroupBy читает входные эле­менты во временный словарь списков, чтобы все элементы с одинаковыми ключами, в конце кон­цов, оказались в одном подсписке. Затем метод создает последовательность групп. Одна группа — это последовательность со свойством Key:

public interface IGrouping <TKey,TElement> : IEnumerable<TElement>, IEnumerable

{

// Свойство Key применяется к подпоследова­тельности в целом

TKey Key { get; }

}

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

73.Оператор соединения на LINQ

Объединение

Метод	Описание
Join	Применяет стратегию просмотра для попар­ного объединения элементов двух кол­лекций и возвращает плоский результи­рующий набор
GroupJoin	То же, что и выше, но возвращается иерар­хический набор ре­зультатов

Операторы Join и GroupJoin

Аргументы оператора Join

Аргумент	Тип
Внешняя последовательность	IEnumerable<TOuter>
Внутренняя последовательность	IEnumerable<TInner>
Внешний селектор ключа	TOuter => TKey
Внутренний селек­тор ключа	Tinner => TKey
Селектор результата	(TOuter,Tinner) => TResult
Аргументы оператора GroupJoin
Аргумент	Тип
Внешняя последовательность	IEnumerable<TOuter>
Внутренняя последовательность	IEnumerable<TInner>
Внешний селектор ключа	TOuter => TKey
Внутренний селек­тор ключа	Tinner => TKey
Селектор результата	(TOuter ,IEnumerable<TInner>) => TResult

Тип возвращаемого значения:

IEnumerable<TResult>

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

from внешняя-переменная in внешняя- перечисляемая -последовательность

join внутренняя-переменная in внутренняя- перечисляемая -последовательность

on внешнее-ключевое-вьражение equals внутрен­нее -ключевое-выражение

[ into идентификатор ]

Описание

Операторы Join и GroupJoin объединяют две входных последовательности в одну выходную. Оператор Join возвращает плоскую последова­тельность, a GroupJoin — иерархическую.

Операторы Join и GroupJoin реализуют стратегию, альтернативную той, что обеспечивают операторы Select и SelectMany. Преимущество операторов Join и GroupJoin состоит в том, что они эффективны для локальных запросов к коллекциям, хра­нящимся в памяти, потому что они вначале загру­жают внутреннюю последовательность в таблицу просмотра, тем самым исключая необходимость в повторном переборе всех внутренних элементов. Недостаток этих операторов заключается в том, что они предлагают эквиваленты только для внут­реннего и левого внешнего объединения. Что каса­ется перекрестного объединения и объединения не по равенству, их по-прежнему приходится делать с помощью операторов Select И SelectMany.

Оператор GroupJoin делает то же самое, что и join, но возвращает не плоский результат, а иерархическую последовательность, разбитую на группы по внешним элементам. Кроме того, этот оператор позволяет выполнять левые внешние объединения.

Синтаксис, облегчающий восприятие, для опера­тора GroupJoin такой же, как и для Join, но требу­ет наличия ключевого слова into.

Вот наиболее типичный пример:

IEnumerable<IEnumerable<Purchase>> query =

from с in customers

join p in purchases on c.ID equals p.CustomerlD

into custPurchases

select custPurchases; // custPurchases — это последовательность

Результатом является последовательность, элемен­ты которой перебираются следующим образом:

foreach (IEnumerable<Purchase> purchaseSequence in query)

foreach (Purchase p in purchaseSequence)

Console.WriteLine (p.Description);