Текст книги "Полное руководство. С# 4.0"

Автор книги: Герберт Шилдт

сообщить о нарушении

Текущая страница: 41 (всего у книги 58 страниц)

Обратите особое внимание на следующий оператор select. select new { Name = item.Name, InStock = entry.InStock };

Он возвращает объект анонимного типа с двумя доступными только для чтения свойствами: Name и InStock. Этим свойствам присваиваются наименование товара и состояние его наличия на складе. Благодаря применению анонимного типа необхо димость в упоминавшемся выше классе Temp отпадает.

Обратите также внимание на цикл foreach, в котором выполняется запрос. Теперь переменная шага этого цикла объявляется с помощью ключевого слова var. Это не обходимо потому, что у типа объекта, хранящегося в переменной inStockList, нет имени. Данная ситуация послужила одной из причин, по которым в C# были внедре ны неявно типизированные переменные, поскольку они нужны для поддержки ано нимных типов.

Прежде чем продолжить изложение, следует отметить еще один заслуживающий внимания аспект анонимных типов. В некоторых случаях, включая и рассмотренный выше, синтаксис анонимного типа упрощается благодаря применению инициализато ра проекции. В данном случае просто указывается имя самого инициализатора. Это имя автоматически становится именем свойства. В качестве примера ниже приведен дру гой вариант оператора select из предыдущей программы. select new { item.Name, entry.InStock };

В данном примере имена свойств остаются такими же, как и прежде, а компилятор автоматически "проецирует" идентификаторы Name и InStock, превращая их в свой ства анонимного типа. Этим свойствам присваиваются прежние значения, обозначае мые item.Name и entry.InStock соответственно. Создание группового объединения

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

В приведенном ниже примере программы групповое объединение используется для составления списка, в котором различные транспортные средства (автомашины, суда и самолеты) организованы по общим для них категориям транспорта: назем ного, морского, воздушного и речного. В этой программе сначала создается класс Transport, связывающий вид транспорта с его классификацией. Затем в методе Main() формируются две входные последовательности. Первая из них представля ет собой массив символьных строк, содержащих названия общих категорий транс порта: наземного, морского, воздушного и речного, а вторая – массив объектов типа Transport, инкапсулирующих различные транспортные средства. Полученное в итоге групповое объединение используется для составления списка транспортных средств, организованных по соответствующим категориям. // Продемонстрировать применение простого группового объединения. using System; using System.Linq; // Этот класс связывает наименование вида транспорта, // например поезда, с общей классификацией транспорта: // наземного, морского, воздушного или речного. class Transport { public string Name { get; set; } public string How { get; set; } public Transport(string n, string h) { Name = n; How = h; } } class GroupJoinDemo { static void Main() { // Массив классификации видов транспорта. string[] travelTypes = { "Воздушный", "Морской", "Наземный", "Речной", }; // Массив видов транспорта. Transport[] transports = { new Transport("велосипед", "Наземный"), new Transport("аэростат", "Воздушный"), new Transport("лодка", "Речной"), new Transport("самолет", "Воздушный"), new Transport("каноэ", "Речной"), new Transport("биплан", "Воздушный"), new Transport("автомашина", "Наземный"), new Transport("судно", "Морской"), new Transport("поезд", "Наземный") }; // Сформировать запрос, в котором групповое // объединение используется для составления списка // видов транспорта по соответствующим категориям. var byHow = from how in travelTypes join trans in transports on how equals trans.How into lst select new { How = how, Tlist = lst }; // Выполнить запрос и вывести его результаты. foreach(var t in byHow) { Console.WriteLine("К категории <{0} транспорт> относится:", t.How); foreach(var m in t.Tlist) Console.WriteLine(" " + m.Name); Console.WriteLine(); } } }

Ниже приведен результат выполнения этой программы. К категории <Воздушный транспорт> относится: аэростат самолет биплан К категории <Морской транспорт> относится: судно К категории <Наземный транспорт> относится: велосипед автомашина поезд К категории <Речной транспорт> относится: лодка каноэ

Главной частью данной программы, безусловно, является следующий запрос. var byHow = from how in travelTypes join trans in transports on how equals trans.How into lst select new { How = how, Tlist = lst };

Этот запрос формируется следующим образом. В операторе from используется переменная диапазона how для охвата всего массива travelTypes. Напомним, что массив travelTypes содержит названия общих категорий транспорта: воздушного, наземного, морского и речного. Каждый вид транспорта объединяется в операторе join со своей категорией. Например, велосипед, автомашина и поезд объединяются с наземным транспортом. Но благодаря оператору into для каждой категории транс порта в операторе join составляется список видов транспорта, относящихся к данной категории. Этот список сохраняется в переменной lst. И наконец, оператор select возвращает объект анонимного, типа, инкапсулирующий каждое значение перемен ной how (категории транспорта) вместе со списком видов транспорта. Именно поэтому для вывода результатов запроса требуются два цикла foreach. foreach(var t in byHow) { Console.WrifeLine("К категории <{0} транспорт> относится:", t.How); foreach(var m in t.Tlist) Console.WriteLine(" " + m.Name); Console.WriteLine(); }

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

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

Методы запроса определяются в классе System.Linq.Enumerable и реализуются в виде методов расширения функций обобщенной формы интерфейса IEnumerable. (Методы запроса определяются также в классе System.Linq.Queryable, расширяю щем функции обобщенной формы интерфейса IQueryable, но этот интерфейс в настоящей главе не рассматривается.) Метод расширения дополняет функции друго го класса, но без наследования. Поддержка методов расширения была внедрена в вер сию C# 3.0 и более подробно рассматривается далее в этой главе. А до тех пор доста точно сказать, что методы запроса могут вызываться только для тех объектов, которые реализуют интерфейс IEnumerable.

В классе Enumerable предоставляется немало методов запроса, но основными счи таются те методы, которые соответствуют описанным ранее операторам запроса. Эти методы перечислены ниже вместе с соответствующими операторами запроса. Следует, однако, иметь в виду, что эти методы имеют также перегружаемые формы, а здесь они представлены лишь в самой простой своей форме. Но именно эта их форма использу ется чаще всего. Оператор запроса Эквивалентный метод запроса select Select(selector) where Where(predicate) orderby OrderBy(keySelector) или OrderByDescending(keySelector) join Join(inner, outerKeySelector, innerKeySelector, resultSelector) group GroupBy(keySelector)

За исключением метода Join(), остальные методы запроса принимают един ственный аргумент, который представляет собой объект некоторой разновидности обобщенного типа Func. Это тип встроенного делегата, объявляемый следующим образом: delegate TResult Func(T arg)

где TResult обозначает тип результата, который дает делегат, а Т – тип элемента. В методах запроса аргументы selector, predicate или keySelector определяют действие, которое предпринимает метод запроса. Например, в методе Where() аргу мент prediсаte определяет порядок отбора данных в запросе. Каждый метод запроса возвращает перечислимый объект. Поэтому результат выполнения одного метода за проса можно использовать для вызова другого, соединяя эти методы в цепочку.

Метод Join() принимает четыре аргумента. Первый аргумент (inner) представляет собой ссылку на вторую объединяемую последовательность, а первой является последо вательность, для которой вызывается метод Join(). Селектор ключа для первой последо вательности передается в качестве аргумента outerKeySelector, а селектор ключа для второй последовательности – в качестве аргумента LnnerKeySelector. Результат объе динения обозначается как аргумент resultSelector. Аргумент outerKeySelector имеет тип Func, аргумент innerKeySelector – тип Func, тогда как аргумент resultSelector – тип Func, где TOuter – тип элемента из вызывающей последовательности; Tinner – тип эле мента из передаваемой последовательности; TResult – тип элемента из объеди няемой в итоге последовательности, возвращаемой в виде перечислимого объекта.

Аргумент метода запроса представляет собой метод, совместимый с указываемой формой делегата Func, но он не обязательно должен быть явно объявляемым мето дом. На самом деле вместо него чаще всего используется лямбда-выражение. Как по яснялось в главе 15, лямбда-выражение обеспечивает более простой, но эффективный способ определения того, что, по существу, является анонимным методом, а компиля тор C# автоматически преобразует лямбда-выражение в форму, которая может быть передана в качестве параметра делегату Func. Благодаря тому что лямбда-выражения обеспечивают более простой и рациональный способ программирования, они исполь зуются во всех примерах, представленных далее в этом разделе. Формирование запросов с помощью методов запроса

Используя методы запроса одновременно с лямбда-выражениями, можно форми ровать запросы, вообще не пользуясь синтаксисом, предусмотренным в C# для запро сов. Вместо этого достаточно вызвать соответствующие методы запроса. Обратимся сначала к простому примеру. Он представляет собой вариант первого примера про граммы из этой главы, переделанный с целью продемонстрировать применение мето дов запроса Where() и Select() вместо соответствующих операторов. // Использовать методы запроса для формирования простого запроса. // Это переделанный вариант первого примера программы из настоящей главы. using System; using System.Linq; class SimpQuery { static void Main() { int[] nums = { 1, -2, 3, 0, -4, 5 }; // Использовать методы Where() и Select() для // формирования простого запроса. var posNums = nums.Where(n => n > 0).Select(r => r); Console.Write("Положительные значения из массива nums: "); // Выполнить запрос и вывести его результаты. foreachfint i in posNums) Console.Write(i + " "); Console.WriteLine(); } }

Эта версия программы дает такой же результат, как и исходная. Положительные значения из массива nums: 1 3 5

Обратите особое внимание в данной программе на следующую строку кода. var posNums = nums.Where(n => n > 0).Select(r => r);

В этой строке кода формируется запрос, сохраняемый в переменной posNums. По этому запросу, в свою очередь, формируется последовательность положительных зна чений, извлекаемых из массива nums. Для этой цели служит метод Where(), отбираю щий запрашиваемые значения, а также метод Select(), избирательно формирующий из этих значений окончательный результат. Метод Where() может быть вызван для массива nums, поскольку во всех массивах реализуется интерфейс IEnumerable, поддерживающий методы расширения запроса.

Формально метод Select() в рассматриваемом здесь примере не нужен, посколь ку это простой запрос. Ведь последовательность, возвращаемая методом Where(), уже содержит конечный результат. Но окончательный выбор можно сделать и по более сложному критерию, как это было показано ранее на примерах использования син таксиса запросов. Так, по приведенному ниже запросу из массива nums возвращаются положительные значения, увеличенные на порядок величины. var posNums = nums.Where(n => n > 0).Select(r => r * 10);

Как и следовало ожидать, в цепочку можно объединять и другие операции над дан ными, получаемыми по запросу. Например, по следующему запросу выбираются по ложительные значения, которые затем сортируются по убывающей и возвращаются в виде результирующей последовательности: var posNums = nums.Where(n => n > 0).OrderByDescending(j => j);

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

В приведенном ниже примере демонстрируется применение метода запроса GroupBy(). Это измененный вариант представленного ранее примера. // Продемонстрировать применение метода запроса GroupBy(). // Это переработанный вариант примера, представленного ранее // для демонстрации синтаксиса запросов. using System; using System.Linq; class GroupByDemo { static void Main() { string[] websites = { "hsNameA.com", "hsNameB.net", "hsNameC.net", "hsNameD.com", "hsNameE.org", "hsNameF.org", "hsNameG.tv", "hsNameH.net", "hsNameI.tv" }; // Использовать методы запроса для группирования // веб-сайтов по имени домена самого верхнего уровня. var webAddrs = websites.Where(w => w.LastIndexOf('.') != 1). GroupBy(x => x.Substring(x.LastIndexOf(".", x.Length))); // Выполнить запрос и вывести его результаты. foreach(var sites in webAddrs) { Console.WriteLine("Веб-сайты, сгруппированные " + "по имени домена " + sites.Key); foreach(var site in sites) Console.WriteLine(" " + site); Console.WriteLine(); } } }

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

Рассмотрим другой пример. Но сначала приведем еще раз запрос из представлен ного ранее примера применения оператора join. var inStockList = from item in items join entry in statusList on item.ItemNumber equals entry.ItemNumber select new Temp(item.Name, entry.InStock);

По этому запросу формируется последовательность, состоящая из объектов, инкап сулирующих наименование товара и состояние его запасов на складе. Вся эта инфор мация получается путем объединения двух источников данных: items и statusList. Ниже приведен переделанный вариант данного запроса, в котором вместо синтаксиса, предусмотренного в C# для запросов, используется метод запроса Join(). // Использовать метод запроса Join() для составления списка // наименований товаров и состояния их запасов на складе. var inStockList = items.Join(statusList, k1 => k1.ItemNumber, k2 => k2.ItemNumber, (k1, k2) => new Temp(k1.Name, k2.InStock) );

В данном варианте именованный класс Temp используется для хранения результи рующего объекта, но вместо него можно воспользоваться анонимным типом. Такой вариант запроса приведен ниже. var inStockList = items.Join(statusList, k1 => k1.ItemNumber, k2 => k2.ItemNumber, (k1, k2) => new { k1.Name, k2.InStock} ); Синтаксис запросов и методы запроса

Как пояснялось в предыдущем разделе, запросы в C# можно формировать двумя способами, используя синтаксис запросов или методы запроса. Любопытно, что оба способа связаны друг с другом более тесно, чем кажется, глядя на исходный код про граммы. Дело в том, что синтаксис запросов компилируется в вызовы методов запроса. Поэтому код where х < 10

будет преобразован компилятором в следующий вызов. Where(х => х < 10)

Таким образом, оба способа формирования запросов в конечном итоге сходятся на одном и том же.

Но если оба способа оказываются в конечном счете равноценными, то какой из них лучше для программирования на С#? В целом, рекомендуется чаще пользоваться син таксисом запросов, поскольку он полностью интегрирован в язык С#, поддерживается соответствующими ключевыми словами и синтаксическим конструкциями. Дополнительные методы расширения, связанные с запросами

Помимо методов, соответствующих операторам запроса, поддерживаемым в С#, име ется ряд других методов расширения, связанных с запросами и зачастую оказывающих помощь в формировании запросов. Эти методы предоставляются в среде .NET Framework и определены для интерфейса IEnumerable в классе Enumerable. Ниже приведе ны наиболее часто используемые методы расширения, связанные с запросами. Многие из них могут перегружаться, поэтому они представлены лишь в самой общей форме. Метод Описание All(predicate) Возвращает логическое значение true, если все элементы в последовательности удовлетворяют условию, задаваемому параметром predicate Any(predicate) Возвращает логическое значение true, если любой элемент в последовательности удовлетворяет условию, задаваемому параметром predicate Average() Возвращает среднее всех значений в числовой последовательности Contains(value) Возвращает логическое значение true, если в последовательности содержится указанный объект Count() Возвращает длину последовательности, т.е. количество составляющих ее элементов First() Возвращает первый элемент в последовательности Last() Возвращает последний элемент в последовательности Max() Возвращает максимальное значение в последовательности Min() Возвращает минимальное значение в последовательности Sum() Возвращает сумму значений в числовой последовательности

Метод Count() уже демонстрировался ранее в этой главе. А в следующей програм ме демонстрируются остальные методы расширения, связанные с запросами. // Использовать ряд методов расширения, определенных в классе Enumerable. using System; using System.Linq; class ExtMethods { static void Main() { int[] nums ={ 3, 1, 2, 5, 4 }; Console.WriteLine("Минимальное значение равно " + nums.Min()); Console.WriteLine("Максимальное значение равно " + nums.Max()); Console.WriteLine("Первое значение равно " + nums.First()); Console.WriteLine("Последнее значение равно " + nums.Last()); Console.WriteLine("Суммарное значение равно " + nums.Sum()); Console.WriteLine("Среднее значение равно " + nums.Average()); if(nums.All(n => n > 0)) Console.WriteLine("Все значения больше нуля."); if(nums.Any(n => (n % 2) == 0)) Console.WriteLine("По крайней мере одно значение является четным."); if(nums.Contains(3)) Console.WriteLine("Массив содержит значение 3."); } }

Вот к какому результату приводит выполнение этой программы. Минимальное значение равно 1 Максимальное значение равно 5 Первое значение равно 3 Последнее значение равно 4 Суммарное значение равно 15 Среднее значение равно 3 Все значения больше нуля. По крайней мере одно значение является четным Массив содержит значение 3.

Методы расширения, связанные с запросами, можно также использовать в самом запросе, основываясь на синтаксисе запросов, предусмотренном в С#. И в действитель ности это делается очень часто. Например, метод Average() используется в приве денной ниже программе для получения последовательности, состоящей только из тех значений, которые оказываются меньше среднего всех значений в массиве. // Использовать метод Average() вместе с синтаксисом запросов. using System; using System.Linq; class ExtMethods2 { static void Main() { int[] nums = { 1, 2, 4, 8, 6, 9, 10, 3, 6, 7 }; var ltAvg = from n in nums let x = nums.Average() where n < x select n; Console.WriteLine("Среднее значение равно " + nums.Average()); Console.Write("Значения меньше среднего: "); // Выполнить запрос и вывести его результаты. foreach(int i in ltAvg) Console.Write(i + " "); Console.WriteLine(); } }

При выполнении этой программы получается следующий результат. Среднее значение равно 5.6 Значения меньше среднего: 1 2 4 3

Обратите особое внимание в этой программе на следующий код запроса. var ltAvg = from n in nums let x = nums.Average() where n < x select n;

Как видите, переменной x в операторе let присваивается среднее всех значений в массиве nums. Это значение получается в результате вызова метода Average() для массива nums. Режимы выполнения запросов: отложенный и немедленный

В LINQ запросы выполняются в двух разных режимах: немедленном и отложенном. Как пояснялось ранее в этой главе, при формировании запроса определяется ряд пра вил, которые не выполняются вплоть до оператора цикла foreach. Это так называе мое отложенное выполнение.

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

Ниже приведен простой пример программы для получения количества положи тельных элементов, содержащихся в последовательности. // Использовать режим немедленного выполнения запроса. using System; using System.Linq; class ImmediateExec { static void Main() { int[] nums = { 1, -2, 3, 0, -4, 5 }; // Сформировать запрос на получение количества // положительных значений в массиве nums. int len = (from n in nums where n > 0 select n).Count (); Console.WriteLine("Количество положительных значений в массиве nums: " + len); } }

Эта программа дает следующий результат. Количество положительных значений в массиве nums: 3

Обратите внимание на то, что цикл foreach не указан в данной программе явным образом. Вместо этого запрос выполняется автоматически благодаря вызову метода расширения Count().

Любопытно, что запрос из приведенной выше программы можно было бы сформи ровать и следующим образом. var posNums = from n in nums where n > 0 select n; int len = posNums.Count(); // запрос выполняется здесь

В данном случае метод Count() вызывается для переменной запроса. И в этот мо мент запрос выполняется для получения подсчитанного количества.

К числу других методов расширения, вызывающих немедленное выполнение за проса, относятся методы ТоАrray() и ToList(). Оба этих метода расширения опре делены в классе Enumerable. Метод ToArray() возвращает результаты запроса в мас сиве, а метод ToList() – результаты запроса в форме коллекции List. (Подробнее о коллекциях речь пойдет в главе 25.) В обоих случаях для получения результатов вы полняется запрос. Например, в следующем фрагменте кода сначала получается массив результатов, сформированных по приведенному выше запросу в переменной posNums, а затем эти результаты выводятся на экран. int[] pnums = posNum.ТоАrrау(); // запрос выполняется здесь foreach(int i in pnums) Console.Write(i + " "); } Деревья выражений

Еще одним средством, связанным с LINQ, является дерево выражений, которое пред ставляет лямбда-выражение в виде данных. Это означает, что само лямбда-выражение нельзя выполнить, но можно преобразовать в исполняемую форму. Деревья выражений инкапсулируются в классе System.Linq.Expressions.Expression.

Они оказываются пригодными в тех случаях, когда запрос выполняется вне програм мы, например средствами SQL в базе данных. Если запрос представлен в виде данных, то его можно преобразовать в формат, понятный для базы данных. Этот процесс вы полняется, например, средствами LINQ to SQL в интегрированной среде разработки Visual Studio. Таким образом, деревья выражений способствуют поддержке в C# раз личных баз данных.

Для получения исполняемой формы дерева выражений достаточно вызвать метод Compile(), определенный в классе Expression. Этот метод возвращает ссылку, ко торая может быть присвоена делегату для последующего выполнения. А тип делегата может быть объявлен собственным или же одним из предопределенных типов деле гата Func в пространстве имен System. Две формы делегата Func уже упоминались ранее при рассмотрении методов запроса, но существует и другие его формы. Деревьям выражений присуще следующее существенное ограничение: они могут представлять только одиночные лямбда-выражения. С их помощью нельзя предста вить блочные лямбда-выражения.

Ниже приведен пример программы, демонстрирующий конкретное применение дерева выражений. В этой программе сначала создается дерево выражений, данные которого представляют метод, определяющий, является ли одно целое число множи телем другого. Затем это дерево выражений компилируется в исполняемый код. И на конец, в этой программе демонстрируется выполнение скомпилированного кода. // Пример простого дерева выражений. using System; using System.Linq; using System.Linq.Expressions; class SimpleExpTree { static void Main() { // Представить лямбда-выражение в виде данных. Expression> IsFactorExp = (n, d) => (d != 0) ? (n % d) == 0 : false; // Скомпилировать данные выражения в исполняемый код. Func IsFactor = IsFactorExp.Compile(); // Выполнить выражение. if(IsFactor(10, 5)) Console.WriteLine("Число 5 является множителем 10."); if(!IsFactor (10, 7)) Console.WriteLine("Число 7 не является множителем 10."); Console.WriteLine(); } }

Вот к какому результату приводит выполнение этой программы. Число 5 является множителем 10. Число 7 не является множителем 10.

Данный пример программы наглядно показывает два основных этапа применения дерева выражений. Сначала в ней создается дерево выражений с помощью следующе го оператора. Expression> IsFactorExp = (n, d) => (d != 0) ? (n % d) == 0 : false;

В этом операторе конструируется представление лямбда-выражения в оперативной памяти. Как пояснялось выше, это представление доступно по ссылке, присваиваемой делегату IsFactorExp. А в следующем операторе данные выражения преобразуются в исполняемый код. Func IsFactor = IsFactorExp.Compile();

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

Обратите также внимание на то, что обозначает тип делегата. В этой форме делегата Func указываются два параметра типа int и воз вращаемый тип bool. В рассматриваемой здесь программе использована именно эта форма делегата Func, совместимая с лямбда-выражениями, поскольку для выраже ния требуются два параметра. Для других лямбда-выражений могут подойти иные формы делегата Func в зависимости от количества требуемых параметров. Вообще говоря, конкретная форма делегата Func должна удовлетворять требованиям лямбда– выражения. Методы расширения

Как упоминалось выше, методы расширения предоставляют средства для расшире ния функций класса, не прибегая к обычному механизму наследования. Методы рас ширения создаются нечасто, поскольку механизм наследования, как правило, пред лагает лучшее решение. Тем не менее знать, как они действуют, никогда не помешает. Ведь они имеют существенное значение для LINQ.

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

Ниже приведена общая форма метода расширения. static возращаемый_тип имя (this тип_вызывающего_объекта ob, список_параметров)

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

В приведенном ниже примере программы создаются три простых метода расширения. // Создать и использовать ряд методов расширения. using System; using System.Globalization; static class MyExtMeths { // Возвратить обратную величину числового значения типа double. public static double Reciprocal(this double v) { return 1.0 / v; } // Изменить на обратный регистр букв в символьной // строке и возвратить результат. public static string RevCase(this string str) { string temp = ""; foreach(char ch in str) { if(Char.IsLower(ch)) temp += Char.ToUpper(ch, CultureInfo. CurrentCulture); else temp += Char.ToLower(ch, CultureInfo.CurrentCulture); } return temp; } // Возвратить абсолютное значение выражения n / d. public static double AbsDivideBy(this double n, double d) { return Math.Abs(n / d); } } class ExtDemo { static void Main() { double val = 8.0; string str = "Alpha Beta Gamma"; // Вызвать метод расширения Reciprocal().. Console.WriteLine("Обратная величина {0} равна {1}", val, val.Reciprocal()); // Вызвать метод расширения RevCase(). Console.WriteLine(str + " после смены регистра: " + str.RevCase()); // Использовать метод расширения AbsDivideBy(). Console.WriteLine("Результат вызова метода val.AbsDivideBy(-2): " + val.AbsDivideBy(-2)); } }

Эта программа дает следующий результат. Обратная величина 8 равна 0.125 Alpha Beta Gamma после смены регистра: aLPHA bЕТА gАММА Результат вызова метода val.AbsDivideBy(-2): 4

В данном примере программы каждый метод расширения содержится в стати ческом классе MyExtMeths. Как пояснялось выше, метод расширения должен быть объявлен в статическом классе. Более того, этот класс должен находиться в области действия своих методов расширения, чтобы ими можно было пользоваться. (Именно поэтому в исходный текст программы следует включить пространство имен System. Linq, так как это дает возможность пользоваться методами расширения, связанными с LINQ.)