Язык программирования C#9 и платформа .NET5 - Эндрю Троелсен

class="code">  Console.WriteLine("Names and Descriptions:");

  IEnumerable<ProductInfoSmall> nameDesc =

    from p

    in products

    select new ProductInfoSmall

      { Name=p.Name, Description=p.Description };

  foreach (ProductInfoSmall item in nameDesc)

  {

    Console.WriteLine(item.ToString());

  }

}

При проецировании LINQ у вас есть выбор, какой метод использовать (в анонимные или в строго типизированные объекты). Решение, которое вы примете, полностью зависит от имеющихся бизнес-требований. 

Подсчет количества с использованием класса Enumerable

Во время проецирования новых пакетов данных у вас может возникнуть необходимость выяснить количество элементов, возвращаемых внутри последовательности. Для определения числа элементов, которые возвращаются из выражения запроса LINQ, можно применять расширяющий метод Count() класса Enumerable. Например, следующий метод будет искать в локальном массиве все объекты string, которые имеют длину, превышающую шесть символов, и выводить их количество:

static void GetCountFromQuery()

{

  string[] currentVideoGames = {"Morrowind", "Uncharted 2",

                                "Fallout 3", "Daxter", "System Shock 2"};

  // Получить количество элементов из запроса.

  int numb =

      (from g in currentVideoGames where g.Length > 6 select g).Count();

  // Вывести количество элементов.

  Console.WriteLine("{0} items honor the LINQ query.", numb);

}

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

Изменить порядок следования элементов в результирующем наборе на противоположный довольно легко с помощью расширяющего метода Reverse<T>() класса Enumerable. Например, в показанном далее методе выбираются все элементы из входного параметра ProductInfo[] в обратном порядке:

static void ReverseEverything(ProductInfo[] products)

{

  Console.WriteLine("Product in reverse:");

  var allProducts = from p in products select p;

  foreach (var prod in allProducts.Reverse())

  {

    Console.WriteLine(prod.ToString());

  }

}

Выражения сортировки

В начальных примерах настоящей главы вы видели, что в выражении запроса может использоваться операция orderby для сортировки элементов в подмножестве по заданному значению. По умолчанию принят порядок по возрастанию, поэтому строки сортируются в алфавитном порядке, числовые значения — от меньшего к большему и т.д. Если вы хотите просматривать результаты в порядке по убыванию, просто включите в выражение запроса операцию descending. Взгляните на следующий метод:

static void AlphabetizeProductNames(ProductInfo[] products)

{

  // Получить названия товаров в алфавитном порядке.

  var subset = from p in products orderby p.Name select p;

  Console.WriteLine("Ordered by Name:");

  foreach (var p in subset)

  {

    Console.WriteLine(p.ToString());

  }

}

Хотя порядок по возрастанию является стандартным, свои намерения можно прояснить, явно указав операцию ascending:

var subset = from p in products orderby p.Name ascending select p;

Для получения элементов в порядке убывания служит операция descending:

var subset = from p in products orderby p.Name descending select p;

LINQ как лучшее средство построения диаграмм Венна

Класс Enumerable поддерживает набор расширяющих методов, которые позволяют применять два (или более) запроса LINQ в качестве основы для нахождения объединений, разностей, конкатенаций и пересечений данных. Первым мы рассмотрим расширяющий метод Except(). Он возвращает результирующий набор LINQ, содержащий разность между двумя контейнерами, которой в этом случае является значение Yugo:

static void DisplayDiff()

{

  List<string> myCars =

    new List<String> {"Yugo", "Aztec", "BMW"};

  List<string> yourCars =

    new List<String>{"BMW", "Saab", "Aztec" };

  var carDiff =

    (from c in myCars select c)

    .Except(from c2 in yourCars select c2);

  Console.WriteLine("Here is what you don't have, but I do:");

  foreach (string s in carDiff)

  {

    Console.WriteLine(s); // Выводит Yugo.

  }

}

Метод Intersect() возвращает результирующий набор, который содержит общие элементы данных в наборе контейнеров. Например, следующий метод возвращает последовательность из Aztec и BMW:

static void DisplayIntersection()

{

  List<string> myCars = new List<String> { "Yugo", "Aztec", "BMW" };

  List<string> yourCars = new List<String> { "BMW", "Saab", "Aztec" };

  // Получить общие члены.

  var carIntersect =

    (from c in myCars select c)

    .Intersect(from c2 in yourCars select c2);

  Console.WriteLine("Here is what we have in common:");

  foreach (string s in carIntersect)

  {

    Console.WriteLine(s); // Выводит Aztec и BMW.

  }

}

Метод Union() возвращает результирующий набор, который включает все члены множества запросов LINQ. Подобно любому объединению, даже если общий член встречается более одного раза, повторяющихся значений в результирующем наборе не будет. Следовательно, показанный ниже метод выведет на консоль значения Yugo, Aztec, BMW и Saab:

static void DisplayUnion()

{

  List<string> myCars =

    new List<string> { "Yugo", "Aztec", "BMW" };

  List<string> yourCars =

    new List<String> { "BMW", "Saab", "Aztec" };

  //  Получить объединение двух контейнеров.

  var carUnion =

    (from c in myCars select c)

    .Union(from c2 in yourCars select c2);

  Console.WriteLine("Here is everything:");

  foreach (string s in carUnion)

  {

    Console.WriteLine(s); // Выводит все общие члены.

  }

}

Наконец, расширяющий метод Concat() возвращает результирующий набор, который является прямой конкатенацией результирующих наборов LINQ. Например, следующий метод выводит на консоль результаты Yugo, Aztec, BMW, Saab и Aztec:

static void DisplayConcat()

{

  List<string> myCars =

    new List<String> { "Yugo", "Aztec", "BMW" };

  List<string> yourCars =

    new List<String> { "BMW", "Saab", "Aztec" };

  var carConcat =

    (from c in myCars select c)

    .Concat(from c2 in yourCars select c2);

  // Выводит Yugo Aztec BMW BMW Saab Aztec.

  foreach (string