Часть IV Дополнительные конструкции программирования на C#
Глава 10 Коллекции и обобщения
Любому приложению, создаваемому с помощью платформы .NET Core, потребуется решать вопросы поддержки и манипулирования набором значений данных в памяти. Значения данных могут поступать из множества местоположений, включая реляционную базу данных, локальный текстовый файл, XML-документ, вызов веб-службы, или через предоставляемый пользователем источник ввода.
В первом выпуске платформы .NET программисты часто применяли классы из пространства имен
System.CollectionsSystem.Collections.GenericВ настоящей главе представлен обзор разнообразных пространств имен и типов коллекций (обобщенных и необобщенных), находящихся в библиотеках базовых классов .NET Core. Вы увидите, что обобщенные контейнеры часто превосходят свои необобщенные аналоги, поскольку они обычно обеспечивают лучшую безопасность в отношении типов и дают выигрыш в плане производительности. После того, как вы научитесь создавать и манипулировать обобщенными элементами внутри платформы, в оставшемся материале главы будет продемонстрировано создание собственных обобщенных методов и типов. Вы узнаете о роли ограничений (и соответствующего ключевого слова
whereПобудительные причины создания классов коллекций
Несомненно, самым элементарным контейнером, который допускается применять для хранения данных приложения, считается массив. В главе 4 вы узнали, что массив C# позволяет определить набор идентично типизированных элементов (в том числе массив элементов типа
System.ObjectSystem.Array// Создать массив строковых данных.string[] strArray = {"First", "Second", "Third" };// Отобразить количество элементов в массиве с помощью свойства Length.Console.WriteLine("This array has {0} items.", strArray.Length);Console.WriteLine();// Отобразить содержимое массива, используя перечислитель.foreach (string s in strArray){ Console.WriteLine("Array Entry: {0}", s);}Console.WriteLine();// Обратить массив и снова вывести его содержимое.Array.Reverse(strArray);foreach (string s in strArray){ Console.WriteLine("Array Entry: {0}", s);}Console.ReadLine();Хотя базовые массивы могут быть удобными для управления небольшими объемами данных фиксированного размера, есть немало случаев, когда требуются более гибкие структуры данных, такие как динамически расширяющийся и сокращающийся контейнер или контейнер, который может хранить только объекты, удовлетворяющие заданному критерию (например, объекты, производные от специфичного базового класса, или объекты, реализующие определенный интерфейс). Когда вы используете простой массив, всегда помните о том, что он был создан с "фиксированным размером". Если вы создали массив из трех элементов, то вы и получите только три элемента; следовательно, представленный далее код даст в результате исключение времени выполнения (конкретно —
IndexOutOfRangeException// Создать массив строковых данных.string[] strArray = { "First", "Second", "Third" };// Попытка добавить новый элемент в конец массива?// Ошибка во время выполнения!strArray[3] = "new item?";...На заметку! На самом деле изменять размер массива можно с применением обобщенного метода
Resize() Чтобы помочь в преодолении ограничений простого массива, библиотеки базовых классов .NET Core поставляются с несколькими пространствами имен, которые содержат классы коллекций. В отличие от простого массива C# классы коллекций построены с возможностью динамического изменения своих размеров на лету по мере вставки либо удаления из них элементов. Более того, многие классы коллекций предлагают улучшенную безопасность в отношении типов и всерьез оптимизированы для обработки содержащихся внутри данных в манере, эффективной с точки зрения затрат памяти. В ходе чтения главы вы быстро заметите, что класс коллекции может принадлежать к одной из двух обширных категорий:
• необобщенные коллекции (в основном находящиеся в пространстве имен
System.Collections• обобщенные коллекции (в основном находящиеся в пространстве имен
System.Collections.GenericНеобобщенные коллекции обычно спроектированы для оперирования типами
System.ObjectstringListSystem.CollectionsSystem.Collections.SpecializedПространство имен System.Collections
С самого первого выпуска платформы .NET программисты часто использовали классы необобщенных коллекций из пространства имен
System.Collecitons
Интерфейсы, реализованные перечисленными в табл. 10.1 классами коллекций, позволяют проникнуть в суть их общей функциональности. В табл. 10.2 представлено описание общей природы основных интерфейсов, часть из которых кратко обсуждалась в главе 8.
Иллюстративный пример: работа с ArrayList
Возможно, вы уже имеете начальный опыт применения (или реализации) некоторых из указанных выше классических структур данных, таких как стеки, очереди или списки. Если это не так, то при рассмотрении обобщенных аналогов таких структур позже в главе будут предоставлены дополнительные сведения об отличиях между ними. А пока что взгляните на пример кода, в котором используется объект
ArrayList// Для доступа к ArrayList потребуется импортировать// пространство имен System.Collections.using System.Collections;ArrayList strArray = new ArrayList();strArray.AddRange(new string[] { "First", "Second", "Third" });// Отобразить количество элементов в ArrayList.System.Console.WriteLine("This collection has {0} items.", strArray.Count);System.Console.WriteLine();// Добавить новый элемент и отобразить текущее их количество.strArray.Add("Fourth!");System.Console.WriteLine("This collection has {0} items.", strArray.Count);// Отобразить содержимое.foreach (string s in strArray){ System.Console.WriteLine("Entry: {0}", s);}System.Console.WriteLine();Обратите внимание, что вы можете добавлять (и удалять) элементы на лету, а контейнер автоматически будет соответствующим образом изменять свой размер.
Как вы могли догадаться, помимо свойства
CountAddRange()Add()ArrayListSystem.CollectionsStackQueueОднако важно отметить, что в большинстве ваших проектов .NET Core классы коллекций из пространства имен
System.CollectionsSystem.Collections.GenericSystem.CollectionsОбзор пространства имен System.Collections.Specialized
System.CollectionsSystem.Collections.Specialized
Кроме указанных конкретных типов классов пространство имен
System.Collections.SpecializedSystem.Collections.GenericНа заметку! В библиотеках базовых классов .NET Core доступны два дополнительных пространства имен, связанные с коллекциями (
System.Collections.ObjectModelSystem.Collections.ConcurrentSystem.Collections.ConcurrentПроблемы, присущие необобщенным коллекциям
Хотя на протяжении многих лет с использованием необобщенных классов коллекций (и интерфейсов) было построено немало успешных приложений .NET и .NET Core, опыт показал, что применение этих типов может привести к возникновению ряда проблем.
Первая проблема заключается в том, что использование классов коллекций
System.CollectionsSystem.Collections.SpecializedSystem.ObjectВторая проблема связана с тем, что большинство необобщенных классов коллекций не являются безопасными в отношении типов, т.к. они были созданы для работы с
System.ObjectПрежде чем вы увидите, как применять обобщения в своих программах, полезно чуть глубже рассмотреть недостатки необобщенных классов коллекций, что поможет лучше понять проблемы, которые был призван решить механизм обобщений. Создайте новый проект консольного приложения по имени
IssuesWithNongenericCollectionsSystemSystem.CollectionsProgram.csusing System;using System.Collections;Проблема производительности
Как уже было указано в главе 4, платформа .NET Core поддерживает две обширные категории данных: типы значений и ссылочные типы. Поскольку в .NET Core определены две основные категории типов, временами возникает необходимость представить переменную одной категории как переменную другой категории. Для этого в C# предлагается простой механизм, называемый упаковкой (boxing), который позволяет хранить данные типа значения внутри ссылочной переменной. Предположим, что в методе по имени
SimpleBoxUnboxOperation()intstatic void SimpleBoxUnboxOperation(){ // Создать переменную ValueType (int). int myInt = 25; // Упаковать int в ссылку на object. object boxedInt = myInt;}Упаковку можно формально определить как процесс явного присваивания данных типа значения переменной
System.ObjectПротивоположная операция также разрешена и называется распаковкой (unboxing). Распаковка представляет собой процесс преобразования значения, хранящегося в объектной ссылке, обратно в соответствующий тип значения в стеке. Синтаксически операция распаковки выглядит как обычная операция приведения, но ее семантика несколько отличается. Среда CoreCLR начинает с проверки того, что полученный тип данных эквивалентен упакованному типу, и если это так, то копирует значение в переменную, находящуюся в стеке. Например, следующие операции распаковки работают успешно при условии, что лежащим в основе типом
boxedIntintstatic void SimpleBoxUnboxOperation(){ // Создать переменную ValueType (int). int myInt = 25; // Упаковать int в ссылку на object. object boxedInt = myInt; // Распаковать ссылку обратно в int. int unboxedInt = (int)boxedInt;}Когда компилятор C# встречает синтаксис упаковки/распаковки, он выпускает код CIL, который содержит коды операций
box/unboxildasm.exe.method assembly hidebysig static void '<$>g__SimpleBoxUnboxOperation|0_0'() cil managed { .maxstack 1 .locals init (int32 V_0, object V_1, int32 V_2) IL_0000: nop IL_0001: ldc.i4.s 25 IL_0003: stloc.0 IL_0004: ldloc.0 IL_0005: box [System.Runtime]System.Int32 IL_000a: stloc.1 IL_000b: ldloc.1 IL_000c: unbox.any [System.Runtime]System.Int32 IL_0011: stloc.2 IL_0012: ret } // end of method '$'::'<$>g__SimpleBoxUnboxOperation|0_0' Помните, что в отличие от обычного приведения распаковка обязана осуществляться только в подходящий тип данных. Попытка распаковать порцию данных в некорректный тип приводит к генерации исключения
InvalidCastExceptiontry/catchintlongstatic void SimpleBoxUnboxOperation(){ // Создать переменную ValueType (int). int myInt = 25; // Упаковать int в ссылку на object. object boxedInt = myInt; // Распаковать в неподходящий тип данных, чтобы // инициировать исключение времени выполнения. try { long unboxedLong = (long)boxedInt; } catch (InvalidCastException ex) { Console.WriteLine(ex.Message); }}На первый взгляд упаковка/распаковка может показаться довольно непримечательным средством языка, с которым связан больше академический интерес, нежели практическая ценность. В конце концов, необходимость хранения локального типа значения в локальной переменной
objectSystem.ObjectДавайте обратимся к практическому применению описанных приемов. Мы будем исследовать класс
System.Collections.ArrayListArrayListSystem.ObjectAdd()Insert()Remove()public class ArrayList : IList, ICloneable{... public virtual int Add(object? value); public virtual void Insert(int index, object? value); public virtual void Remove(object? obj); public virtual object? this[int index] {get; set; }}Класс
ArrayListobjectstatic void WorkWithArrayList(){ // Типы значений автоматически упаковываются при передаче // методу, который требует экземпляр типа object. ArrayList myInts = new ArrayList(); myInts.Add(10); myInts.Add(20); myInts.Add(35);}Хотя здесь числовые данные напрямую передаются методам, которые требуют экземпляров типа
objectArrayListArrayListSystem.ObjectSystem.Int32static void WorkWithArrayList(){ // Типы значений автоматически упаковываются, // когда передаются члену, принимающему object. ArrayList myInts = new ArrayList(); myInts.Add(10); myInts.Add(20); myInts.Add(35); // Распаковка происходит, когда объект преобразуется // обратно в данные, расположенные в стеке. int i = (int)myInts[0]; // Теперь значение вновь упаковывается, т.к. // метод WriteLine() требует типа object! Console.WriteLine("Value of your int: {0}", i);}Обратите внимание, что расположенное в стеке значение типа
System.Int32ArrayList.Add()System.ObjectSystem.ObjectSystem.Int32ArrayListConsole.WriteLine()System.ObjectУпаковка и распаковка удобны с точки зрения программиста, но такой упрощенный подход к передаче данных между стеком и кучей влечет за собой проблемы, связанные с производительностью (снижение скорости выполнения и увеличение размера кода), а также приводит к утрате безопасности в отношении типов. Чтобы понять проблемы с производительностью, примите во внимание действия, которые должны произойти при упаковке и распаковке простого целочисленного значения.
1. Новый объект должен быть размещен в управляемой куче.
2. Значение данных, находящееся в стеке, должно быть передано в выделенное место в памяти.
3. При распаковке значение, которое хранится в объекте, находящемся в куче, должно быть передано обратно в стек.
4. Неиспользуемый в дальнейшем объект, расположенный в куче, будет (со временем) удален сборщиком мусора.
Несмотря на то что показанный конкретный метод
WorkWithArrayList()ArrayListtry/catchПроблема безопасности в отношении типов
Мы уже затрагивали проблему безопасности в отношении типов, когда рассматривали операции распаковки. Вспомните, что данные должны быть распакованы в тот же самый тип, с которым они объявлялись перед упаковкой. Однако существует еще один аспект безопасности в отношении типов, который необходимо иметь в виду в мире без обобщений: тот факт, что классы из пространства имен
System.CollectionsSystem.ObjectArrayListstatic void ArrayListOfRandomObjects(){ // ArrayList может хранить вообще все что угодно. ArrayList allMyObjects = new ArrayList(); allMyObjects.Add(true); allMyObjects.Add(new OperatingSystem(PlatformID.MacOSX, new Version(10, 0))); allMyObjects.Add(66); allMyObjects.Add(3.14);}В ряде случаев вам будет требоваться исключительно гибкий контейнер, который способен хранить буквально все (как было здесь показано). Но большую часть времени вас интересует безопасный в отношении типов контейнер, который может работать только с определенным типом данных. Например, вы можете нуждаться в контейнере, хранящем только объекты типа подключения к базе данных, растрового изображения или класса, реализующего интерфейс
IPointyДо появления обобщений единственный способ решения проблемы, касающейся безопасности в отношении типов, предусматривал создание вручную специального класса (строго типизированной) коллекции. Предположим, что вы хотите создать специальную коллекцию, которая способна содержать только объекты типа
Personnamespace IssuesWithNonGenericCollections{ public class Person { public int Age {get; set;} public string FirstName {get; set;} public string LastName {get; set;} public Person(){} public Person(string firstName, string lastName, int age) { Age = age; FirstName = firstName; LastName = lastName; } public override string ToString() { return $"Name: {FirstName} {LastName}, Age: {Age}"; } }}Чтобы построить коллекцию, которая способна хранить только объекты
PersonSystem.Collection.ArrayListPeopleCollectionPersonSystem.ObjectSystem.CollectionsSystem.Collections.Specializedusing System.Collections;namespace IssuesWithNonGenericCollections{ public class PersonCollection : IEnumerable { private ArrayList arPeople = new ArrayList(); // Приведение для вызывающего кода. public Person GetPerson(int pos) => (Person)arPeople[pos]; // Вставка только объектов Person. public void AddPerson(Person p) { arPeople.Add(p); } public void ClearPeople() { arPeople.Clear(); } public int Count => arPeople.Count; // Поддержка перечисления с помощью foreach. IEnumerator IEnumerable.GetEnumerator() => arPeople.GetEnumerator(); }}Обратите внимание, что класс
PeopleCollectionIEnumerableforeachGetPerson()AddPerson()PersonusingProgram.csUserPersonCollection()using System;using System.Collections;using IssuesWithNonGenericCollections;// Операторы верхнего уровня в Program.csstatic void UsePersonCollection(){ Console.WriteLine("***** Custom Person Collection *****\n"); PersonCollection myPeople = new PersonCollection(); myPeople.AddPerson(new Person("Homer", "Simpson", 40)); myPeople.AddPerson(new Person("Marge", "Simpson", 38)); myPeople.AddPerson(new Person("Lisa", "Simpson", 9)); myPeople.AddPerson(new Person("Bart", "Simpson", 7)); myPeople.AddPerson(new Person("Maggie", "Simpson", 2)); // Это вызовет ошибку на этапе компиляции! // myPeople.AddPerson(new Car()); foreach (Person p in myPeople) { Console.WriteLine(p); }}Хотя специальные коллекции гарантируют безопасность в отношении типов, такой подход обязывает создавать (в основном идентичные) специальные коллекции для всех уникальных типов данных, которые планируется в них помещать. Таким образом, если нужна специальная коллекция, которая могла бы оперировать только с классами, производными от базового класса
Carusing System.Collections;public class CarCollection : IEnumerable{ private ArrayList arCars = new ArrayList(); // Приведение для вызывающего кода. public Car GetCar(int pos) => (Car) arCars[pos]; // Вставка только объектов Car. public void AddCar(Car c) { arCars.Add(c); } public void ClearCars() { arCars.Clear(); } public int Count => arCars.Count; // Поддержка перечисления с помощью foreach. IEnumerator IEnumerable.GetEnumerator() => arCars.GetEnumerator();}Тем не менее, класс специальной коллекции ничего не делает для решения проблемы с накладными расходами по упаковке/распаковке. Даже если создать специальную коллекцию по имени
IntCollectionSystem.Int32System.ArrayArrayListpublic class IntCollection : IEnumerable{ private ArrayList arInts = new ArrayList(); // Получение int (выполняется распаковка). public int GetInt(int pos) => (int)arInts[pos]; // Вставка int (выполняется упаковка). public void AddInt(int i) { arInts.Add(i); } public void ClearInts() { arInts.Clear(); } public int Count => arInts.Count; IEnumerator IEnumerable.GetEnumerator() => arInts.GetEnumerator();}Независимо от того, какой тип выбран для хранения целых чисел, в случае применения необобщенных контейнеров затруднительного положения с упаковкой избежать невозможно.
Первый взгляд на обобщенные коллекции
Когда используются классы обобщенных коллекций, все описанные выше проблемы исчезают, включая накладные расходы на упаковку/распаковку и отсутствие безопасности в отношении типов. К тому же необходимость в создании специального класса (обобщенной) коллекции становится довольно редкой. Вместо построения уникальных классов, которые могут хранить объекты людей, автомобилей и целые числа, можно задействовать класс обобщенной коллекции и указать тип хранимых элементов. Добавьте в начало файла
Program.csusingusing System.Collections.Generic;Взгляните на показанный ниже метод (добавленный в конец файла
Program.csListSystem.Collection.Genericstatic void UseGenericList(){ Console.WriteLine("***** Fun with Generics *****\n"); // Этот объект List<> может хранить только объекты Person. List morePeople = new List(); morePeople.Add(new Person ("Frank", "Black", 50)); Console.WriteLine(morePeople[0]); // Этот объект ListO может хранить только целые числа. List moreInts = new List(); moreInts.Add(10); moreInts.Add(2); int sum = moreInts[0] + moreInts[1]; // Ошибка на этапе компиляции! Объект Person // не может быть добавлен в список элементов int! // moreInts.Add(new Person());}Первый контейнер
ListPersonListArrayList• Обобщения обеспечивают лучшую производительность, т.к. лишены накладных расходов по упаковке/распаковке, когда хранят типы значений.
• Обобщения безопасны в отношении типов, потому что могут содержать только объекты указанного типа.
• Обобщения значительно сокращают потребность в специальных типах коллекций, поскольку при создании обобщенного контейнера указывается "вид типа".
Роль параметров обобщенных типов
Обобщенные классы, интерфейсы, структуры и делегаты вы можете обнаружить повсюду в библиотеках базовых классов .NET Core, и они могут быть частью любого пространства имен .NET Core. Кроме того, имейте в виду, что применение обобщений далеко не ограничивается простым определением класса коллекции. Разумеется, в оставшихся главах книги вы встретите случаи использования многих других обобщений для самых разных целей.
На заметку! Обобщенным образом могут быть записаны только классы, структуры, интерфейсы и делегаты, но не перечисления.
Глядя на обобщенный элемент в документации по .NET Core или в браузере объектов Visual Studio, вы заметите пару угловых скобок с буквой или другой лексемой внутри. На рис. 10.1 показано окно браузера объектов Visual Studio, в котором отображается набор обобщенных элементов из пространства имен
System.Collections.GenericList
Формально эти лексемы называются параметрами типа, но в более дружественных к пользователю терминах на них можно ссылаться просто как на заполнители. Конструкцию
<Т>ТIEnumerableIEnumerableТНа заметку! Имя параметра типа (заполнитель) роли не играет и зависит от предпочтений разработчика, создавшего обобщенный элемент. Однако обычно имя
TТКеуКTValueVКогда вы создаете обобщенный объект, реализуете обобщенный интерфейс или вызываете обобщенный член, на вас возлагается обязанность по предоставлению значения для параметра типа. Многочисленные примеры вы увидите как в этой главе, так и в остальных материалах книги. Тем не менее, для начала рассмотрим основы взаимодействия с обобщенными типами и членами.
Указание параметров типа для обобщенных классов и структур
При создании экземпляра обобщенного класса или структуры вы указываете параметр типа, когда объявляете переменную и когда вызываете конструктор. Как было показано в предыдущем фрагменте кода, в методе
UseGenericList()List// Этот объект List<> может хранить только объекты Person.List morePeople = new List(); // Этот объект List<> может хранить только целые числа.List moreInts = new List(); Первую строку приведенного выше кода можно трактовать как "список
List<>ТТPersonЕсли вы просмотрите полное объявление обобщенного класса
ListТ// Частичное определение класса List. namespace System.Collections.Generic{ public class List : IList, IList, IReadOnlyList { ... public void Add(T item); public void AddRange(IEnumerable<T> collection); public ReadOnlyCollection<T> AsReadOnly(); public int BinarySearch(T item); public bool Contains(T item); public void CopyTo(T[] array); public int FindIndex(System.Predicate<T> match); public T FindLast(System.Predicate<T> match); public bool Remove(T item); public int RemoveAll(System.Predicate<T> match); public T[] ToArray(); public bool TrueForAll(System.Predicate<T> match); public T this[int index] { get; set; } }}В случае создания
ListPersonListnamespace System.Collections.Generic{ public class List<Person> : IList<Person>, IList, IReadOnlyList<Person> { ... public void Add(Person item); public void AddRange(IEnumerable<Person> collection); public ReadOnlyCollection<Person> AsReadOnly(); public int BinarySearch(Person item); public bool Contains(Person item); public void CopyTo(Person[] array); public int FindIndex(System.Predicate<Person> match); public Person FindLast(System.Predicate<Person> match); public bool Remove(Person item); public int RemoveAll(System.Predicate<Person> match); public Person[] ToArray(); public bool TrueForAll(System.Predicate<Person> match); public Person this[int index] { get; set; } }}Несомненно, когда вы создаете в коде переменную обобщенного типа
ListListУказание параметров типа для обобщенных членов
В необобщенном классе или структуре разрешено поддерживать обобщенные свойства. В таких случаях необходимо также указывать значение заполнителя во время вызова метода. Например, класс
System.ArraySort()Sort() Тintint[] myInts = { 10, 4, 2, 33, 93 };// Указание заполнителя для обобщенного метода Sort<>().Array.Sort(myInts); foreach (int i in myInts){ Console.WriteLine(i);}Указание параметров типов для обобщенных интерфейсов
Обобщенные интерфейсы обычно реализуются при построении классов или структур,которые нуждаются в поддержке разнообразных аспектов поведения платформы (скажем, клонирования, сортировки и перечисления). В главе 8 вы узнали о нескольких необобщенных интерфейсах, таких как
IComparableIEnumerableIEnumeratorIComparerIComparablepublic interface IComparable{ int CompareTo(object obj);}В главе 8 этот интерфейс также был реализован классом
CarSystem.Objectpublic class Car : IComparable { ... // Реализация IComparable. int IComparable.CompareTo(object obj) { if (obj is Car temp) { return this.CarID.CompareTo(temp.CarID); } throw new ArgumentException("Parameter is not a Car!"); // Параметр не является объектом типа Car! } }Теперь представим, что применяется обобщенный аналог данного интерфейса:
public interface IComparable{ int CompareTo(T obj);}В таком случае код реализации будет значительно яснее:
public class Car : IComparable{ ... // Реализация IComparable. int IComparable.CompareTo(Car obj) { if (this.CarID > obj.CarID) { return 1; } if (this.CarID < obj.CarID) { return -1; } return 0; }}Здесь уже не нужно проверять, относится ли входной параметр к типу
CarCarSystem.Collections.GenericПространство имен System.Collections.Generic
Когда вы строите приложение .NET Core и необходим способ управления данными в памяти, классы из пространства имен
System.Collections.GenericSystem.Collections.GenericВ действительности вы сможете найти некоторое количество обобщенных интерфейсов, которые расширяют свои необобщенные аналоги, что может показаться странным.Тем не менее, за счет этого реализующие их классы будут также поддерживать унаследованную функциональность, которая имеется в их необобщенных родственных версиях. Например, интерфейс
IEnumerableIEnumerable
В пространстве имен
System.Collections.Generic
В пространстве имен
System.Collections.GenericLinkedListNodeLinkedListKeyNotFoundExceptionSystem.Collections.GenericВ любом случае следующая ваша задача состоит в том, чтобы научиться использовать некоторые из упомянутых классов обобщенных коллекций. Тем не менее, сначала полезно ознакомиться со средством языка C# (введенным в версии .NET 3.5), которое упрощает заполнение данными обобщенных (и необобщенных) коллекций.
Синтаксис инициализации коллекций
В главе 4 вы узнали о синтаксисе инициализации массивов, который позволяет устанавливать элементы новой переменной массива во время ее создания. С ним тесно связан синтаксис инициализации коллекций. Данное средство языка C# позволяет наполнять многие контейнеры (такие как
ArrayListListFunWithCollectionInitializationProgram.csusingusing System;using System.Collections;using System.Collections.Generic;using System.Drawing;На заметку! Синтаксис инициализации коллекций может применяться только к классам, которые поддерживают метод
Add()ICollectionICollectionВзгляните на приведенные ниже примеры:
// Инициализация стандартного массива.int[] myArrayOfInts = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };// Инициализация обобщенного List<> с элементами int.List myGenericList = new List { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; // Инициализация ArrayList числовыми данными.ArrayList myList = new ArrayList { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };Если контейнером является коллекция классов или структур, тогда синтаксис инициализации коллекций можно смешивать с синтаксисом инициализации объектов, получая функциональный код. Вспомните класс
PointXYListPointList myListOfPoints = new List { new Point { X = 2, Y = 2 }, new Point { X = 3, Y = 3 }, new Point { X = 4, Y = 4 }};foreach (var pt in myListOfPoints){ Console.WriteLine(pt);}Преимущество этого синтаксиса связано с сокращением объема клавиатурного ввода. Хотя вложенные фигурные скобки могут затруднять чтение кода, если не позаботиться о надлежащем форматировании, вы только вообразите себе объем кода, который пришлось бы написать для наполнения следующего списка
ListRectangleList myListOfRects = new List { new Rectangle { Height = 90, Width = 90, Location = new Point { X = 10, Y = 10 }}, new Rectangle { Height = 50,Width = 50, Location = new Point { X = 2, Y = 2 }},};foreach (var r in myListOfRects){ Console.WriteLine(r);}
Работа с классом List
Создайте новый проект консольного приложения под названием
FunWithGenericCollectionsPerson.csPersonnamespace FunWithGenericCollections{ public class Person { public int Age {get; set;} public string FirstName {get; set;} public string LastName {get; set;} public Person(){} public Person(string firstName, string lastName, int age) { Age = age; FirstName = firstName; LastName = lastName; } public override string ToString() { return $"Name: {FirstName} {LastName}, Age: {Age}"; } }}Удалите сгенерированный код из файла
Program.csusingusing System;using System.Collections.Generic;using FunWithGenericCollections;Первым будет исследоваться обобщенный класс
ListListSystem.Collections.GenericProgramUseGenericList()ListPersonPersonAgeFirstNameLastNameToString()static void UseGenericList(){ // Создать список объектов Person и заполнить его с помощью // синтаксиса инициализации объектов и коллекции. List people = new List() { new Person {FirstName= "Homer", LastName="Simpson", Age=47}, new Person {FirstName= "Marge", LastName="Simpson", Age=45}, new Person {FirstName= "Lisa", LastName="Simpson", Age=9}, new Person {FirstName= "Bart", LastName="Simpson", Age=8} }; // Вывести количество элементов в списке. Console.WriteLine("Items in list: {0}", people.Count); // Выполнить перечисление по списку. foreach (Person p in people) { Console.WriteLine(p); } // Вставить новый объект Person. Console.WriteLine("\n->Inserting new person."); people.Insert(2, new Person { FirstName = "Maggie", LastName = "Simpson", Age = 2 }); Console.WriteLine("Items in list: {0}", people.Count); // Скопировать данные в новый массив. Person[] arrayOfPeople = people.ToArray(); foreach (Person p in arrayOfPeople) // Вывести имена { Console.WriteLine("First Names: {0}", p.FirstName); }}Здесь для наполнения списка
ListAdd()Insert()Insert()ListНаконец, обратите внимание на вызов метода
ToArray()PersonListUseGenericList()***** Fun with Generic Collections *****Items in list: 4Name: Homer Simpson, Age: 47Name: Marge Simpson, Age: 45Name: Lisa Simpson, Age: 9Name: Bart Simpson, Age: 8->Inserting new person.Items in list: 5First Names: HomerFirst Names: MargeFirst Names: MaggieFirst Names: LisaFirst Names: BartВ классе
ListStackQueueSortedSet
Работа с классом Stack
Класс
StackStackPush()Pop()Personstatic void UseGenericStack(){ Stack stackOfPeople = new(); stackOfPeople.Push(new Person { FirstName = "Homer", LastName = "Simpson", Age = 47 }); stackOfPeople.Push(new Person { FirstName = "Marge", LastName = "Simpson", Age = 45 }); stackOfPeople.Push(new Person { FirstName = "Lisa", LastName = "Simpson", Age = 9 }); // Просмотреть верхний элемент, вытолкнуть его и просмотреть снова.. Console.WriteLine("First person is: {0}", stackOfPeople.Peek()); Console.WriteLine("Popped off {0}", stackOfPeople.Pop()); Console.WriteLine("\nFirst person is: {0}", stackOfPeople.Peek()); Console.WriteLine("Popped off {0}", stackOfPeople.Pop()); Console.WriteLine("\nFirst person item is: {0}", stackOfPeople.Peek()); Console.WriteLine("Popped off {0}", stackOfPeople.Pop()); try { Console.WriteLine("\nnFirst person is: {0}", stackOfPeople.Peek()); Console.WriteLine("Popped off {0}", stackOfPeople.Pop()); } catch (InvalidOperationException ex) { Console.WriteLine("\nError! {0}", ex.Message); // Ошибка! Стек пуст }}В коде строится стек, который содержит информацию о трех лицах, добавленных в алфавитном порядке следования их имен:
HomerMargeLisaРеек()Реек()PersonPop()Peek()Реек()Pop()***** Fun with Generic Collections *****First person is: Name: Lisa Simpson, Age: 9Popped off Name: Lisa Simpson, Age: 9First person is: Name: Marge Simpson, Age: 45Popped off Name: Marge Simpson, Age: 45First person item is: Name: Homer Simpson, Age: 47Popped off Name: Homer Simpson, Age: 47Error! Stack empty.
Работа с классом Queue
Очереди — это контейнеры, которые обеспечивают доступ к элементам в стиле "первый вошел — первый вышел" (FIFO). К сожалению, людям приходится сталкиваться с очередями практически ежедневно: в банке, в супермаркете, в кафе. Когда нужно смоделировать сценарий, в котором элементы обрабатываются в режиме FIFO, класс
QueueQueue
Теперь давайте посмотрим на описанные методы в работе. Можно снова задействовать класс
PersonQueuestatic void UseGenericQueue(){ // Создать очередь из трех человек. Queue peopleQ = new(); peopleQ.Enqueue(new Person {FirstName= "Homer", LastName="Simpson", Age=47}); peopleQ.Enqueue(new Person {FirstName= "Marge", LastName="Simpson", Age=45}); peopleQ.Enqueue(new Person {FirstName= "Lisa", LastName="Simpson", Age=9}); // Заглянуть, кто первый в очереди. Console.WriteLine("{0} is first in line!", peopleQ.Peek().FirstName); // Удалить всех из очереди. GetCoffee(peopleQ.Dequeue()); GetCoffee(peopleQ.Dequeue()); GetCoffee(peopleQ.Dequeue()); // Попробовать извлечь кого-то из очереди снова try { GetCoffee(peopleQ.Dequeue()); } catch(InvalidOperationException e) { Console.WriteLine("Error! {0}", e.Message); //Ошибка! Очередь пуста. } // Локальная вспомогательная функция static void GetCoffee(Person p) { Console.WriteLine("{0} got coffee!", p.FirstName); }}Здесь с применением метода
Enqueue()QueuePeek()QueueDequeue()GetCoffee()UseGenericQueue()***** Fun with Generic Collections *****Homer is first in line!Homer got coffee!Marge got coffee!Lisa got coffee!Error! Queue empty.
Работа с классом SortedSet
Класс
SortedSetSortedSetIComparerНачните с создания нового класса по имени
SortPeopleByAgeIComparerТPersonCompare()using System.Collections.Generic;namespace FunWithGenericCollections{ class SortPeopleByAge : IComparer { public int Compare(Person firstPerson, Person secondPerson) { if (firstPerson?.Age > secondPerson?.Age) { return 1; } if (firstPerson?.Age < secondPerson?.Age) { return -1; } return 0; } }}Теперь добавьте в класс
ProgramSortedSetstatic void UseSortedSet(){ // Создать несколько объектов Person с разными значениями возраста. SortedSet setOfPeople = new SortedSet(new SortPeopleByAge()) { new Person {FirstName= "Homer", LastName="Simpson", Age=47}, new Person {FirstName= "Marge", LastName="Simpson", Age=45}, new Person {FirstName= "Lisa", LastName="Simpson", Age=9}, new Person {FirstName= "Bart", LastName="Simpson", Age=8} }; // Обратите внимание, что элементы отсортированы по возрасту. foreach (Person p in setOfPeople) { Console.WriteLine(p); } Console.WriteLine(); // Добавить еще несколько объектов Person с разными значениями возраста. setOfPeople.Add(new Person { FirstName = "Saku", LastName = "Jones", Age = 1 }); setOfPeople.Add(new Person { FirstName = "Mikko", LastName = "Jones", Age = 32 }); // Элементы по-прежнему отсортированы по возрасту. foreach (Person p in setOfPeople) { Console.WriteLine(p); }}Запустив приложение, легко заметить, что список объектов будет всегда упорядочен на основе значения свойства
Age***** Fun with Generic Collections *****Name: Bart Simpson, Age: 8Name: Lisa Simpson, Age: 9Name: Marge Simpson, Age: 45Name: Homer Simpson, Age: 47Name: Saku Jones, Age: 1Name: Bart Simpson, Age: 8Name: Lisa Simpson, Age: 9Name: Mikko Jones, Age: 32Name: Marge Simpson, Age: 45Name: Homer Simpson, Age: 47
Работа с классом Dictionary
Еще одной удобной обобщенной коллекцией является класс
DictionaryListHomerКак и другие классы коллекций, наполнять
DictionaryAdd()DictionaryВзгляните на следующий метод, который наполняет
DictionaryDictionaryТКеуTValuestringPersonprivate static void UseDictionary(){ // Наполнить с помощью метода Add() Dictionary peopleA = new Dictionary(); peopleA.Add("Homer", new Person { FirstName = "Homer", LastName = "Simpson", Age = 47 }); peopleA.Add("Marge", new Person { FirstName = "Marge", LastName = "Simpson", Age = 45 }); peopleA.Add("Lisa", new Person { FirstName = "Lisa", LastName = "Simpson", Age = 9 }); // Получить элемент с ключом Homer. Person homer = peopleA["Homer"]; Console.WriteLine(homer); // Наполнить с помощью синтаксиса инициализации. Dictionary peopleB = new Dictionary() { { "Homer", new Person { FirstName = "Homer", LastName = "Simpson", Age = 47 } }, { "Marge", new Person { FirstName = "Marge", LastName = "Simpson", Age = 45 } }, { "Lisa", new Person { FirstName = "Lisa", LastName = "Simpson", Age = 9 } } }; // Получить элемент с ключом Lisa. Person lisa = peopleB["Lisa"]; Console.WriteLine(lisa);}Наполнять
DictionarypersonB// Наполнить с помощью синтаксиса инициализации словарей.Dictionary peopleC = new Dictionary() { ["Homer"] = new Person { FirstName = "Homer", LastName = "Simpson", Age = 47 }, ["Marge"] = new Person { FirstName = "Marge", LastName = "Simpson", Age = 45 }, ["Lisa"] = new Person { FirstName = "Lisa", LastName = "Simpson", Age = 9 }};Пространство имен System.Collections.ObjectModel
Теперь, когда вы понимаете, как работать с основными обобщенными классами, можно кратко рассмотреть дополнительное пространство имен, связанное с коллекциями —
System.Collections.ObjectModel
Класс
ObservableCollectionReadOnlyObservableCollection
Работа с классом ObservableCollection
Создайте новый проект консольного приложения по имени
FunWithObservableCollectionsSystem.Collections.ObjectModelObservableCollectionListObservableCollectionCollectionChangedПодобно любому другому событию событие
CollectionChangedNotifyCollectionChangedEventHandlerobjectNotifyCollectionChangedEventArgsPersonCollectionChangedusing System;using System.Collections.ObjectModel;using System.Collections.Specialized;using FunWithObservableCollections;// Сделать коллекцию наблюдаемой// и добавить в нее несколько объектов Person.ObservableCollection people = new ObservableCollection() { new Person{ FirstName = "Peter", LastName = "Murphy", Age = 52 }, new Person{ FirstName = "Kevin", LastName = "Key", Age = 48 },};// Привязаться к событию CollectionChanged.people.CollectionChanged += people_CollectionChanged;static void people_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e){ throw new NotImplementedException();}Входной параметр
NotifyCollectionChangedEventArgsOldIternsNewItemsCollectionChangedActionNotifyCollectionChangedEventArgsActionNotifyCollectionChangedActionpublic enum NotifyCollectionChangedAction{ Add = 0, Remove = 1, Replace = 2, Move = 3, Reset = 4,}Ниже показана реализация обработчика событий
CollectionChangedusingSystem.Collections.Specializedusing System.Collections.Specialized;...static void people_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e){ // Выяснить действие, которое привело к генерации события. Console.WriteLine("Action for this event: {0}", e.Action); // Было что-то удалено. if (e.Action == NotifyCollectionChangedAction.Remove) { Console.WriteLine("Here are the OLD items:"); // старые элементы foreach (Person p in e.OldItems) { Console.WriteLine(p.ToString()); } Console.WriteLine(); } // Было что-то добавлено. if (e.Action == NotifyCollectionChangedAction.Add) { // Теперь вывести новые элементы, которые были вставлены. Console.WriteLine("Here are the NEW items:"); // Новые элементы foreach (Person p in e.NewItems) { Console.WriteLine(p.ToString()); } }}Модифицируйте вызывающий код для добавления и удаления элемента:
// Добавить новый элемент.people.Add(new Person("Fred", "Smith", 32));// Удалить элемент.people.RemoveAt(0);В результате запуска программы вы получите вывод следующего вида:
Action for this event: AddHere are the NEW items:Name: Fred Smith, Age: 32Action for this event: RemoveHere are the OLD items:Name: Peter Murphy, Age: 52На этом исследование различных пространств имен, связанных с коллекциями, завершено. В конце главы будет также объясняться, как и для чего строить собственные обобщенные методы и обобщенные типы.
Создание специальных обобщенных методов
Несмотря на то что большинство разработчиков обычно применяют обобщенные типы, имеющиеся в библиотеках базовых классов, существует также возможность построения собственных обобщенных методов и специальных обобщенных типов. Давайте посмотрим, как включать обобщения в свои проекты. Первым делом будет построен обобщенный метод обмена. Начните с создания нового проекта консольного приложения по имени
CustomGenericMethodsПостроение специальных обобщенных методов представляет собой более развитую версию традиционной перегрузки методов. В главе 2 вы узнали, что перегрузка — это действие по определению нескольких версий одного метода, которые отличаются друг от друга количеством или типами параметров.
Хотя перегрузка является полезным средством объектно-ориентированного языка, проблема заключается в том, что при этом довольно легко получить в итоге огромное количество методов, которые по существу делают одно и то же. Например, пусть необходимо создать методы, которые позволяют менять местами два фрагмента данных посредством простой процедуры. Вы можете начать с написания нового статического класса с методом, который способен оперировать целочисленными значениями:
using System;namespace CustomGenericMethods{ static class SwapFunctions { // Поменять местами два целочисленных значения. static void Swap(ref int a, ref int b) { int temp = a; a = b; b = temp; } }}Пока все идет хорошо. Но теперь предположим, что нужно менять местами также и два объекта
PersonSwap()// Поменять местами два объекта Person.static void Swap(ref Person a, ref Person b){ Person temp = a; a = b; b = temp;}Вне всяких сомнений вам должно быть ясно, чем все закончится. Если также понадобится менять местами два значения с плавающей точкой, два объекта растровых изображений, два объекта автомобилей, два объекта кнопок или что-нибудь еще, то придется писать дополнительные методы, что в итоге превратится в настоящий кошмар при сопровождении. Можно было бы построить один (необобщенный) метод, оперирующий с параметрами типа
objectНаличие группы перегруженных методов, отличающихся только входными аргументами — явный признак того, что обобщения могут облегчить ситуацию. Рассмотрим следующий обобщенный метод
Swap() Т// Этот метод будет менять местами два элемента// типа, указанного в параметре <Т>.static void Swap(ref T a, ref T b) { Console.WriteLine("You sent the Swap() method a {0}", typeof(T)); T temp = a; a = b; b = temp;}Обратите внимание, что обобщенный метод определен за счет указания параметра типа после имени метода, но перед списком параметров. Здесь заявлено, что метод
Swap() <Т>typeof()Console.WriteLine("***** Fun with Custom Generic Methods *****\n");// Поменять местами два целочисленных значения.int a = 10, b = 90;Console.WriteLine("Before swap: {0}, {1}", a, b);SwapFunctions.Swap(ref a, ref b); Console.WriteLine("After swap: {0}, {1}", a, b);Console.WriteLine();// Поменять местами два строковых значения.string s1 = "Hello", s2 = "There";Console.WriteLine("Before swap: {0} {1}!", s1, s2);SwapFunctions.Swap(ref s1, ref s2); Console.WriteLine("After swap: {0} {1}!", s1, s2);Console.ReadLine();Вот вывод:
***** Fun with Custom Generic Methods *****Before swap: 10, 90You sent the Swap() method a System.Int32After swap: 90, 10Before swap: Hello There!You sent the Swap() method a System.StringAfter swap: There Hello!Главное преимущество такого подхода в том, что придется сопровождать только одну версию
Swap() Выведение параметров типа
При вызове обобщенных методов вроде
Swap() System.Boolean// Компилятор выведет тип System.Boolean.bool b1 = true, b2 = false;Console.WriteLine("Before swap: {0}, {1}", b1, b2);SwapFunctions.Swap(ref b1, ref b2);Console.WriteLine("After swap: {0}, {1}", b1, b2);Несмотря на то что компилятор может определить параметр типа на основе типа данных, который применялся в объявлениях
b1b2SwapFunctions.Swap(ref b1, ref b2); Такой подход позволяет другим программистам понять, что метод на самом деле является обобщенным. Кроме того, выведение типов параметров работает только в случае, если обобщенный метод принимает, по крайней мере, один параметр. Например, пусть в классе
ProgramDisplayBaseClass() static void DisplayBaseClass() { // BaseType - метод, используемый в рефлексии; // он будет описан в главе 17 Console.WriteLine("Base class of {0} is: {1}.", typeof(T), typeof(T).BaseType);}В таком случае при его вызове потребуется указать параметр типа:
...// Если метод не принимает параметров,// то должен быть указан параметр типа.DisplayBaseClass(); DisplayBaseClass(); // Ошибка на этапе компиляции! Нет параметров?// Должен быть предоставлен заполнитель!// DisplayBaseClass();Console.ReadLine();Разумеется, обобщенные методы не обязаны быть статическими, как в приведенных выше примерах. Кроме того, применимы все правила и варианты для необобщенных методов.
Создание специальных обобщенных структур и классов
Так как вы уже знаете, каким образом определять и вызывать обобщенные методы, наступило время уделить внимание конструированию обобщенной структуры (процесс построения обобщенного класса идентичен) в новом проекте консольного приложения по имени
GenericPointPointPoint// Точка с координатами типа int.Point p = new Point(10, 10); // Точка с координатами типа double.Point p2 = new Point(5.4, 3.3); // Точка с координатами типа string.Point p3 = new Point(""",""3""); Создание точки с использованием строк поначалу может показаться несколько странным, но возьмем случай мнимых чисел, и тогда применение строк для значений
XYPointnamespace GenericPoint{ // Обобщенная структура Point. public struct Point { // Обобщенные данные состояния. private T _xPos; private T _yPos; // Обобщенный конструктор. public Point(T xVal, T yVal) { _xPos = xVal; _yPos = yVal; } // Обобщенные свойства. public T X { get => _xPos; set => _xPos = value; } public T Y { get => _yPos; set => _yPos = value; } public override string ToString() => $"[{_xPos}, {_yPos}]"; }}Как видите, структура
PointВыражения default вида значений в обобщениях
С появлением обобщений ключевое слово
defaultswitch• числовые типы имеют стандартное значение
0• ссылочные типы имеют стандартное значение
null• поля структур устанавливаются в
0nullЧтобы сбросить экземпляр
PointXY0stringdefault(Т)defaultResetPoint()// Сбросить поля в стандартное значение параметра типа.// Ключевое слово default в языке C# перегружено.// При использовании с обобщениями оно представляет// стандартное значение параметра типа.public void ResetPoint(){ _xPos = default(T); _yPos = default(T);}Теперь, располагая методом
ResetPoint()Pointusing System;using GenericPoint;Console.WriteLine("***** Fun with Generic Structures *****\n");// Точка с координатами типа int.Point p = new Point(10, 10); Console.WriteLine("p.ToString()={0}", p.ToString());p.ResetPoint();Console.WriteLine("p.ToString()={0}", p.ToString());Console.WriteLine();// Точка с координатами типа double.Point p2 = new Point(5.4, 3.3); Console.WriteLine("p2.ToString()={0}", p2.ToString());p2.ResetPoint();Console.WriteLine("p2.ToString()={0}", p2.ToString());Console.WriteLine();// Точка с координатами типа string.Point p3 = new Point("i", "3i"); Console.WriteLine("p3.ToString()={0}", p3.ToString());p3.ResetPoint();Console.WriteLine("p3.ToString()={0}", p3.ToString());Console.ReadLine();Ниже приведен вывод:
***** Fun with Generic Structures *****p.ToString()=[10, 10]p.ToString()=[0, 0]p2.ToString()=[5.4, 3.3]p2.ToString()=[0, 0]p3.ToString()=[i, 3i]p3.ToString()=[, ]Выражения default литерального вида (нововведение в версии 7.1)
В дополнение к установке стандартного значения свойства в версии C# 7.1 появились выражения
defaultdefaultResetPoint(),public void ResetPoint(){ _xPos = default; _yPos = default;}Выражение
defaultPointPoint p4 = default; Console.WriteLine("p4.ToString()={0}", p4.ToString());Console.WriteLine();Point p5 = default; Console.WriteLine("p5.ToString()={0}", p5.ToString()); Сопоставление с образцом в обобщениях (нововведение в версии 7.1)
Еще одним обновлением в версии C# 7.1 является возможность использования сопоставления с образцом в обобщениях. Взгляните на приведенный далее метод, проверяющий экземпляр
Pointstatic void PatternMatching(Point p) { switch (p) { case Point pString: Console.WriteLine("Point is based on strings"); return; case Point pInt: Console.WriteLine("Point is based on ints"); return; }}Для использования кода сопоставления с образцом модифицируйте операторы верхнего уровня следующим образом:
Point p4 = default; Point p5 = default; PatternMatching(p4);PatternMatching(p5); Ограничение параметров типа
Как объяснялось в настоящей главе, любой обобщенный элемент имеет, по крайней мере, один параметр типа, который необходимо указывать во время взаимодействия с данным обобщенным типом или его членом. Уже одно это обстоятельство позволяет строить код, безопасный в отношении типов; тем не менее, вы также можете применять ключевое слово where для определения особых требований к отдельному параметру типа.
С помощью ключевого слова
where
Возможно, применять ключевое слово
wherewhereПримеры использования ключевого слова where
Начнем с предположения о том, что создан специальный обобщенный класс, и необходимо гарантировать наличие в параметре типа стандартного конструктора. Это может быть полезно, когда специальный обобщенный класс должен создавать экземпляры типа
ТТТ// Класс MyGenericClass является производным от object, в то время как// содержащиеся в нем элементы должны иметь стандартный конструктор.public class MyGenericClass where T : new() { ...}Обратите внимание, что конструкция where указывает параметр типа, подлежащий ограничению, за которым следует операция двоеточия. После операции двоеточия перечисляются все возможные ограничения (в данном случае — стандартный конструктор). Вот еще один пример:
// Класс MyGenericClass является производным от object, в то время как// содержащиеся в нем элементы должны относиться к классу, реализующему// интерфейс IDrawable, и поддерживать стандартный конструктор.public class MyGenericClass where T : class, IDrawable, new() { ...}Здесь к типу
TclassТIDrawableТnew()// Ошибка! Ограничение new() должно быть последним в списке!public class MyGenericClass where T : new(), class, IDrawable { ...}При создании класса обобщенной коллекции с несколькими параметрами типа можно указывать уникальный набор ограничений для каждого параметра, применяя отдельные конструкции
where// Тип <К> должен расширять SomeBaseClass и иметь стандартный конструктор,// в то время как тип <Т> должен быть структурой и реализовывать// обобщенный интерфейс IComparable.public class MyGenericClass where K : SomeBaseClass, new() where T : struct, IComparable{ ...}Необходимость построения полного специального обобщенного класса коллекции возникает редко; однако ключевое слово
whereSwap() // Этот метод меняет местами любые структуры, но не классы.static void Swap(ref T a, ref T b) where T : struct { ...}Обратите внимание, что если ограничить метод
Swap() stringstringОтсутствие ограничений операций
В завершение главы следует упомянуть об еще одном факте, связанном с обобщенными методами и ограничениями. При создании обобщенных методов может оказаться неожиданным получение ошибки на этапе компиляции в случае применения к параметрам типа любых операций C# (
+-*==// Ошибка на этапе компиляции! Невозможно// применять операции к параметрам типа!public class BasicMath{ public T Add(T arg1, T arg2) { return arg1 + arg2; } public T Subtract(T arg1, T arg2) { return arg1 - arg2; } public T Multiply(T arg1, T arg2) { return arg1 * arg2; } public T Divide(T arg1, T arg2) { return arg1 / arg2; }}К сожалению, приведенный выше класс
BasicMath<Т>+-*/// Только в целях иллюстрации!public class BasicMath where T : operator +, operator -, operator *, operator /{ public T Add(T arg1, T arg2) { return arg1 + arg2; } public T Subtract(T arg1, T arg2) { return arg1 - arg2; } public T Multiply(T arg1, T arg2) { return arg1 * arg2; } public T Divide(T arg1, T arg2) { return arg1 / arg2; }}Увы, ограничения операций в текущей версии C# не поддерживаются. Однако достичь желаемого результата можно (хотя и с дополнительными усилиями) путем определения интерфейса, который поддерживает такие операции (интерфейсы C# могут определять операции!), и указания ограничения интерфейса для обобщенного класса. В любом случае первоначальный обзор построения специальных обобщенных типов завершен. Во время исследования типа делегата в главе 12 мы вновь обратимся к теме обобщений.
Резюме
Глава начиналась с рассмотрения необобщенных типов коллекций в пространствах имен
System.CollectionsSystem.Collections.SpecializedSystem.Collections.GenericSystem.Collections.ObjectModelВы видели, что обобщенный элемент позволяет указывать заполнители (параметры типа), которые задаются во время создания объекта (или вызова в случае обобщенных методов). Хотя чаще всего вы будете просто применять обобщенные типы, предоставляемые библиотеками базовых классов .NET, также имеется возможность создавать собственные обобщенные типы (и обобщенные методы). При этом допускается указывать любое количество ограничений (с использованием ключевого слова
whereВ качестве финального замечания: не забывайте, что обобщения можно обнаружить во многих местах внутри библиотек базовых классов .NET. Здесь мы сосредоточились конкретно на обобщенных коллекциях. Тем не менее, по мере проработки материала оставшихся глав (и освоения платформы) вы наверняка найдете обобщенные классы, структуры и делегаты в том или ином пространстве имен. Кроме того, будьте готовы столкнуться с обобщенными членами в необобщенном классе!
Глава 11 Расширенные средства языка C#
В настоящей главе ваше понимание языка программирования C# будет углублено за счет исследования нескольких более сложных тем. Сначала вы узнаете, как реализовывать и применять индексаторный метод. Такой механизм C# позволяет строить специальные типы, которые предоставляют доступ к внутренним элементам с использованием синтаксиса, подобного синтаксису массивов. Вы научитесь перегружать разнообразные операции (
+-<>Затем будут обсуждаться темы, которые особенно полезны при работе с API-интерфейсами LINQ (хотя они применимы и за рамками контекста LINQ): расширяющие методы и анонимные типы.
В завершение главы вы узнаете, каким образом создавать контекст "небезопасного" кода, чтобы напрямую манипулировать неуправляемыми указателями. Хотя использование указателей в приложениях C# — довольно редкое явление, понимание того, как это делается, может пригодиться в определенных обстоятельствах, связанных со сложными сценариями взаимодействия.
Понятие индексаторных методов
Программистам хорошо знаком процесс доступа к индивидуальным элементам, содержащимся внутри простого массива, с применением операции индекса (
[]// Организовать цикл по аргументам командной строки// с использованием операции индекса.for(int i = 0; i < args.Length; i++){ Console.WriteLine("Args: {0}", args[i]);}// Объявить массив локальных целочисленных значений.int[] myInts = { 10, 9, 100, 432, 9874};// Применить операцию индекса для доступа к каждому элементу.for(int j = 0; j < myInts.Length; j++){ Console.WriteLine("Index {0} = {1} ", j, myInts[j]);}Console.ReadLine();Приведенный код ни в коем случае не является чем-то совершенно новым. Но в языке C# предлагается возможность проектирования специальных классов и структур, которые могут индексироваться подобно стандартному массиву, за счет определения индексаторного метода.Такое языковое средство наиболее полезно при создании специальных классов коллекций (обобщенных или необобщенных).
Прежде чем выяснять, каким образом реализуется специальный индексатор, давайте начнем с того, что продемонстрируем его в действии. Пусть к специальному типу
PersonCollectionIssuesWithNonGenericCollectionsSimpleIndexerusing System;using System.Collections.Generic;using System.Data;using SimpleIndexer;// Индексаторы позволяют обращаться к элементам в стиле массива.Console.WriteLine("***** Fun with Indexers *****\n");PersonCollection myPeople = new PersonCollection();// Добавить объекты с применением синтаксиса индексатора.myPeople[0] = new Person("Homer", "Simpson", 40);myPeople[1] = new Person("Marge", "Simpson", 38);myPeople[2] = new Person("Lisa", "Simpson", 9);myPeople[3] = new Person("Bart", "Simpson", 7);myPeople[4] = new Person("Maggie", "Simpson", 2);// Получить и отобразить элементы, используя индексатор.for (int i = 0; i < myPeople.Count; i++){ Console.WriteLine("Person number: {0}", i); // номер лица Console.WriteLine("Name: {0} {1}", myPeople[i].FirstName, myPeople[i].LastName); // имя и фамилия Console.WriteLine("Age: {0}", myPeople[i].Age); // возраст Console.WriteLine();}Как видите, индексаторы позволяют манипулировать внутренней коллекцией подобъектов подобно стандартному массиву. Но тут возникает серьезный вопрос: каким образом сконфигурировать класс
PersonCollectionthis[]PersonCollectionusing System.Collections;namespace SimpleIndexer{ // Добавить индексатор к существующему определению класса. public class PersonCollection : IEnumerable { private ArrayList arPeople = new ArrayList(); ... // Специальный индексатор для этого класса. public Person this[int index] { get => (Person)arPeople[index]; set => arPeople.Insert(index, value); } }}Если не считать факт использования ключевого слова
thisgetArrayListsetPersonInsert()ArrayListИндексаторы являются еще одной формой "синтаксического сахара", учитывая то, что такую же функциональность можно получить с применением "нормальных" открытых методов наподобие
AddPerson()GetPerson()Несмотря на то что создание индексаторных методов является вполне обычным явлением при построении специальных коллекций, не забывайте, что обобщенные типы предлагают такую функциональность в готовом виде. В следующем методе используется обобщенный список
ListPersonListusing System.Collections.Generic;static void UseGenericListOfPeople(){ List myPeople = new List(); myPeople.Add(new Person("Lisa", "Simpson", 9)); myPeople.Add(new Person("Bart", "Simpson", 7)); // Изменить первый объект лица с помощью индексатора. myPeople[0] = new Person("Maggie", "Simpson", 2); // Получить и отобразить каждый элемент, используя индексатор. for (int i = 0; i < myPeople.Count; i++) { Console.WriteLine("Person number: {0}", i); Console.WriteLine("Name: {0} {1}", myPeople[i].FirstName, myPeople[i].LastName); Console.WriteLine("Age: {0}", myPeople[i].Age); Console.WriteLine(); }}Индексация данных с использованием строковых значений
В текущей версии класса
PersonCollectionPersonSystem.Collections.Generic.DictionaryArrayListDictionaryusing System.Collections;using System.Collections.Generic;namespace SimpleIndexer{ public class PersonCollectionStringIndexer : IEnumerable { private Dictionary listPeople = new Dictionary(); // Этот индексатор возвращает объект лица на основе строкового индекса. public Person this[string name] { get => (Person)listPeople[name]; set => listPeople[name] = value; } public void ClearPeople() { listPeople.Clear(); } public int Count => listPeople.Count; IEnumerator IEnumerable.GetEnumerator() => listPeople.GetEnumerator(); }}Теперь вызывающий код способен взаимодействовать с содержащимися внутри объектами
PersonConsole.WriteLine("***** Fun with Indexers *****\n");PersonCollectionStringIndexer myPeopleStrings = new PersonCollectionStringIndexer();myPeopleStrings["Homer"] = new Person("Homer", "Simpson", 40);myPeopleStrings["Marge"] = new Person("Marge", "Simpson", 38);// Получить объект лица Homer и вывести данные.Person homer = myPeopleStrings["Homer"];Console.ReadLine();И снова, если бы обобщенный тип
DictionaryПерегрузка индексаторных методов
Индексаторные методы могут быть перегружены в отдельном классе или структуре. Таким образом, если имеет смысл предоставить вызывающему коду возможность доступа к элементам с применением числового индекса или строкового значения, то в одном типе можно определить несколько индексаторов. Например, в ADO.NET (встроенный API-интерфейс .NET для доступа к базам данных) класс
DataSeTablesDataTableCollectionDataTableCollectionDataTablepublic sealed class DataTableCollection : InternalDataCollectionBase{... // Перегруженные индексаторы. public DataTable this[int index] { get; } public DataTable this[string name] { get; } public DataTable this[string name, string tableNamespace] { get; }}Поддержка индексаторных методов вполне обычна для типов в библиотеках базовых классов. Поэтому даже если текущий проект не требует построения специальных индексаторов для классов и структур, помните о том, что многие типы уже поддерживают такой синтаксис.
Многомерные индексаторы
Допускается также создавать индексаторный метод, который принимает несколько параметров. Предположим, что есть специальная коллекция, хранящая элементы в двумерном массиве. В таком случае индексаторный метод можно определить следующим образом:
public class SomeContainer{ private int[,] my2DintArray = new int[10, 10]; public int this[int row, int column] { /* получить или установить значение в двумерном массиве */ }}Если только вы не строите высокоспециализированный класс коллекций, то вряд ли будете особо нуждаться в создании многомерного индексатора. Пример ADO.NET еще раз демонстрирует, насколько полезной может оказаться такая конструкция. Класс
DataTableХотя объекты
DataTableDataTableDataTableSystem.Datastatic void MultiIndexerWithDataTable(){ // Создать простой объект DataTable с тремя столбцами. DataTable myTable = new DataTable(); myTable.Columns.Add(new DataColumn("FirstName")); myTable.Columns.Add(new DataColumn("LastName")); myTable.Columns.Add(new DataColumn("Age")); // Добавить строку в таблицу. myTable.Rows.Add("Mel", "Appleby", 60); // Использовать многомерный индексатор для вывода деталей первой строки. Console.WriteLine("First Name: {0}", myTable.Rows[0][0]); Console.WriteLine("Last Name: {0}", myTable.Rows[0][1]); Console.WriteLine("Age : {0}", myTable.Rows[0][2]);}Начиная с главы 21, мы продолжим рассмотрение ADO.NET, так что не переживайте, если что-то в приведенном выше коде выглядит незнакомым. Пример просто иллюстрирует, что индексаторные методы способны поддерживать множество измерений, а при правильном применении могут упростить взаимодействие с объектами, содержащимися в специальных коллекциях.
Определения индексаторов в интерфейсных типах
Индексаторы могут определяться в выбранном типе интерфейса .NET Core, чтобы позволить поддерживающим типам предоставлять специальные реализации. Ниже показан простой пример интерфейса, который задает протокол для получения строковых объектов с использованием числового индексатора:
public interface IStringContainer{ string this[int index] { get; set; }}При таком определении интерфейса любой класс или структура, которые его реализуют, должны поддерживать индексатор с чтением/записью, манипулирующий элементами с применением числового значения. Вот частичная реализация класса подобного вида:
class SomeClass : IStringContainer{ private List myStrings = new List(); public string this[int index] { get => myStrings[index]; set => myStrings.Insert(index, value); }}На этом первая крупная тема настоящей главы завершена. А теперь давайте перейдем к исследованиям языкового средства, которое позволяет строить специальные классы и структуры, уникальным образом реагирующие на внутренние операции С#. Итак, займемся концепцией перегрузки операций.
Понятие перегрузки операций
Как и любой язык программирования, C# имеет заготовленный набор лексем, используемых для выполнения базовых операций над встроенными типами. Например, вы знаете, что операция
+// Операция + с целыми числами.int a = 100;int b = 240;int c = a + b; // с теперь имеет значение 340Опять-таки, здесь нет ничего нового, но задумывались ли вы когда-нибудь о том, что одну и ту же операцию
+// Операция + со строками.string s1 = "Hello";string s2 = " world!";string s3 = s1 + s2; // s3 теперь имеет значение "Hello World!"Операция
++Язык C# дает возможность строить специальные классы и структуры, которые также уникально реагируют на один и тот же набор базовых лексем (вроде операции
+
Перегрузка бинарных операций
Чтобы проиллюстрировать процесс перегрузки бинарных операций, рассмотрим приведенный ниже простой класс
PointOverloadedOpsusing System;namespace OverloadedOps{ // Простой будничный класс С#. public class Point { public int X {get; set;} public int Y {get; set;} public Point(int xPos, int yPos) { X = xPos; Y = yPos; } public override string ToString() => $"[{this.X}, {this.Y}]"; }}Рассуждая логически, суммирование объектов
PointPointPointXYPointusing System;using OverloadedOps;// Сложение и вычитание двух точек?Console.WriteLine("***** Fun with Overloaded Operators *****\n");// Создать две точки.Point ptOne = new Point(100, 100);Point ptTwo = new Point(40, 40);Console.WriteLine("ptOne = {0}", ptOne);Console.WriteLine("ptTwo = {0}", ptTwo);// Сложить две точки, чтобы получить большую точку?Console.WriteLine("ptOne + ptTwo: {0} ", ptOne + ptTwo);// Вычесть одну точку из другой, чтобы получить меньшую? Console.WriteLine("ptOne - ptTwo: {0} ", ptOne - ptTwo); Console.ReadLine();Тем не менее, с существующим видом класса
PointPoint+-static+-Point// Более интеллектуальный тип Point.public class Point{ ... // Перегруженная операция +. public static Point operator + (Point p1, Point p2) => new Point(p1.X + p2.X, p1.Y + p2.Y); // Перегруженная операция -. public static Point operator - (Point p1, Point p2) => new Point(p1.X - p2.X, p1.Y - p2.Y);}Логика, положенная в основу операции
+PointPointp1 + р2operator +// Псевдокод: Point рЗ = Point.operator+ (pi, р2)Point p3 = p1 + p2;Аналогично выражение
pi - р2// Псевдокод: Point р4 = Point.operator- (pi, р2)Point p4 = p1 - p2;После произведенной модификации типа
PointPoint***** Fun with Overloaded Operators *****ptOne = [100, 100]ptTwo = [40, 40]ptOne + ptTwo: [140, 140]ptOne - ptTwo: [60, 60]При перегрузке бинарной операции передавать ей два параметра того же самого типа не обязательно. Если это имеет смысл, тогда один из аргументов может относиться к другому типу. Например, ниже показана перегруженная операция
+Pointpublic class Point{ ... public static Point operator + (Point p1, int change) => new Point(p1.X + change, p1.Y + change); public static Point operator + (int change, Point p1) => new Point(p1.X + change, p1.Y + change);}Обратите внимание, что если вы хотите передавать аргументы в любом порядке, то потребуется реализовать обе версии метода (т.е. нельзя просто определить один из методов и рассчитывать, что компилятор автоматически будет поддерживать другой). Теперь новые версии операции
+// Выводит [110, 110].Point biggerPoint = ptOne + 10;Console.WriteLine("ptOne + 10 = {0}", biggerPoint);// Выводит [120, 120].Console.WriteLine("10 + biggerPoint = {0}", 10 + biggerPoint);Console.WriteLine();А как насчет операций += и -=?
Если до перехода на C# вы имели дело с языком C++, тогда вас может удивить отсутствие возможности перегрузки операций сокращенного присваивания (
+=-+Point+-// Перегрузка бинарных операций автоматически обеспечивает// перегрузку сокращенных операций....// Автоматически перегруженная операция +=Point ptThree = new Point(90, 5);Console.WriteLine("ptThree = {0}", ptThree);Console.WriteLine("ptThree += ptTwo: {0}", ptThree += ptTwo);// Автоматически перегруженная операция -=Point ptFour = new Point(0, 500);Console.WriteLine("ptFour = {0}", ptFour);Console.WriteLine("ptFour -= ptThree: {0}", ptFour -= ptThree);Console.ReadLine();Перегрузка унарных операций
В языке C# также разрешено перегружать унарные операции, такие как
++--staticoperatorPointpublic class Point{ ... // Добавить 1 к значениям X/Y входного объекта Point. public static Point operator ++(Point p1) => new Point(p1.X+1, p1.Y+1); // Вычесть 1 из значений X/Y входного объекта Point. public static Point operator --(Point p1) => new Point(p1.X-1, p1.Y-1);}В результате появляется возможность инкрементировать и декрементировать значения
XYPoint...// Применение унарных операций ++ и -- к объекту Point.Point ptFive = new Point(1, 1);Console.WriteLine("++ptFive = {0}", ++ptFive); // [2, 2]Console.WriteLine("--ptFive = {0}", --ptFive); // [1, 1]// Применение тех же операций в виде постфиксного инкремента/декремента.Point ptSix = new Point(20, 20);Console.WriteLine("ptSix++ = {0}", ptSix++); // [20, 20]Console.WriteLine("ptSix-- = {0}", ptSix--); // [21, 21]Console.ReadLine();В предыдущем примере кода специальные операции
++--++pt++++ptПерегрузка операций эквивалентности
Как упоминалось в главе 6, метод
System.Object.Equals()Equals()System.Object.GetHashCode()==!=Point// В данной версии типа Point также перегружены операции == и !=.public class Point{ ... public override bool Equals(object o) => o.ToString() == this.ToString(); public override int GetHashCode() => this.ToString().GetHashCode(); // Теперь перегрузить операции == и !=. public static bool operator ==(Point p1, Point p2) => p1.Equals(p2); public static bool operator !=(Point p1, Point p2) => !p1.Equals(p2);}Обратите внимание, что для выполнения всей работы в реализациях операций
==!=Equals()Point// Использование перегруженных операций эквивалентности....Console.WriteLine("ptOne == ptTwo : {0}", ptOne == ptTwo);Console.WriteLine("ptOne != ptTwo : {0}", ptOne != ptTwo);Console.ReadLine();Как видите, сравнение двух объектов с использованием хорошо знакомых операций
==!=Object.Equals()==!=Перегрузка операций сравнения
В главе 8 было показано, каким образом реализовывать интерфейс
IComparable<><=>=<>PointPoint// Использование перегруженных операций < и >....Console.WriteLine("ptOne < ptTwo : {0}", ptOne < ptTwo);Console.WriteLine("ptOne > ptTwo : {0}", ptOne > ptTwo);Console.ReadLine();Когда интерфейс
IComparable// Объекты Point также можно сравнивать посредством операций сравнения.public class Point : IComparable{ ... public int CompareTo(Point other) { if (this.X > other.X && this.Y > other.Y) { return 1; } if (this.X < other.X && this.Y < other.Y) { return -1; } return 0; } public static bool operator <(Point p1, Point p2) => p1.CompareTo(p2) < 0; public static bool operator >(Point p1, Point p2) => p1.CompareTo(p2) > 0; public static bool operator <=(Point p1, Point p2) => p1.CompareTo(p2) <= 0; public static bool operator >=(Point p1, Point p2) => p1.CompareTo(p2) >= 0;}Финальные соображения относительно перегрузки операций
Как уже упоминалось, язык C# предоставляет возможность построения типов, которые могут уникальным образом реагировать на разнообразные встроенные хорошо известные операции. Перед добавлением поддержки такого поведения в классы вы должны удостовериться в том, что операции, которые планируется перегружать, имеют какой-нибудь смысл в реальности.
Например, пусть перегружена операция умножения для класса
MiniVanMiniVanMiniVan// Что?! Понять это непросто...MiniVan newVan = myVan * yourVan;Перегрузка операций обычно полезна только при построении атомарных типов данных. Векторы, матрицы, текст, точки, фигуры, множества и т.п. будут подходящими кандидатами на перегрузку операций, но люди, менеджеры, автомобили, подключения к базе данных и веб-страницы — нет. В качестве эмпирического правила запомните, что если перегруженная операция затрудняет понимание пользователем функциональности типа, то не перегружайте ее. Используйте такую возможность с умом.
Понятие специальных преобразований типов
Давайте теперь обратимся к теме, тесно связанной с перегрузкой операций, а именно — к специальным преобразованиям типов. Чтобы заложить фундамент для последующего обсуждения, кратко вспомним понятие явных и неявных преобразований между числовыми данными и связанными типами классов.
Повторение: числовые преобразования
В терминах встроенных числовых типов (
sbyteintfloatint a = 123;long b = a; // Неявное преобразование из int в long.int c = (int) b; // Явное преобразование из long в int.Повторение: преобразования между связанными типами классов
В главе 6 было показано, что типы классов могут быть связаны классическим наследованием (отношение "является"). В таком случае процесс преобразования C# позволяет осуществлять приведение вверх и вниз по иерархии классов. Например, производный класс всегда может быть неявно приведен к базовому классу. Тем не менее, если вы хотите сохранить объект базового класса в переменной производного класса, то должны выполнить явное приведение:
// Два связанных типа классов.class Base{}class Derived : Base{}// Неявное приведение производного класса к базовому.Base myBaseType;myBaseType = new Derived();// Для сохранения ссылки на базовый класс в переменной// производного класса требуется явное преобразование.Derived myDerivedType = (Derived)myBaseType;Продемонстрированное явное приведение работает из-за того, что классы
BaseDerivedmyBaseTypeDerivedmyBaseTypeBaseInvalidCastExceptionas// Неявное приведение производного класса к базовому.Base myBaseType2 = new();// Сгенерируется исключение InvalidCastException :// Derived myDerivedType2 = (Derived)myBaseType2 as Derived;// Исключения нет, myDerivedType2 равен null:Derived myDerivedType2 = myBaseType2 as Derived;Но что если есть два типа классов в разных иерархиях без общего предка (кроме
System.ObjectВ качестве связанного замечания обратимся к типам значений (структурам). Предположим, что имеются две структуры с именами
SquareRectangleНесмотря на то что в структурах можно было бы создать вспомогательные методы (наподобие
Rectangle.ToSquare()()// Преобразовать Rectangle в Square!Rectangle rect = new Rectangle{ Width = 3; Height = 10;}Square sq = (Square)rect;Создание специальных процедур преобразования
Начните с создания нового проекта консольного приложения по имени
CustomConversionsexplicitimplicitusing System;namespace CustomConversions{ public struct Rectangle { public int Width {get; set;} public int Height {get; set;} public Rectangle(int w, int h) { Width = w; Height = h; } public void Draw() { for (int i = 0; i < Height; i++) { for (int j = 0; j < Width; j++) { Console.Write("*"); } Console.WriteLine(); } } public override string ToString() => $"[Width = {Width}; Height = {Height}]"; }}using System;namespace CustomConversions{ public struct Square { public int Length {get; set;} public Square(int l) : this() { Length = l; } public void Draw() { for (int i = 0; i < Length; i++) { for (int j = 0; j < Length; j++) { Console.Write("*"); } Console.WriteLine(); } } public override string ToString() => $"[Length = {Length}]"; // Rectangle можно явно преобразовывать в Square. public static explicit operator Square(Rectangle r) { Square s = new Square {Length = r.Height}; return s; } }}Обратите внимание, что в текущей версии типа
SquareexplicitimplicitstaticВ данном случае предположение заключается в том, что квадрат (будучи геометрической фигурой с четырьмя сторонами равной длины) может быть получен из высоты прямоугольника. Таким образом, вот как преобразовать
RectangleSquareusing System;using CustomConversions;Console.WriteLine("***** Fun with Conversions *****\n");// Создать экземпляр Rectangle.Rectangle r = new Rectangle(15, 4);Console.WriteLine(r.ToString());r.Draw();Console.WriteLine();// Преобразовать r в Square на основе высоты Rectangle.Square s = (Square)r;Console.WriteLine(s.ToString());s.Draw();Console.ReadLine();Ниже показан вывод:
***** Fun with Conversions *****[Width = 15; Height = 4]************************************************************[Length = 4]****************Хотя преобразование
RectangleSquareSquare// Этот метод требует параметр типа Square.static void DrawSquare(Square sq){ Console.WriteLine(sq.ToString()); sq.Draw();}Благодаря наличию операции явного преобразования в типе
SquareDrawSquare()Rectangle...// Преобразовать Rectangle в Square для вызова метода.Rectangle rect = new Rectangle(10, 5);DrawSquare((Square)rect);Console.ReadLine(); Дополнительные явные преобразования для типа Square
Теперь, когда экземпляры
RectangleSquareSquareSquareSquareint...// Преобразование int в Square.Square sq2 = (Square)90;Console.WriteLine("sq2 = {0}", sq2);// Преобразование Square в int.int side = (int)sq2;Console.WriteLine("Side length of sq2 = {0}", side);Console.ReadLine();Ниже показаны изменения, внесенные в структуру
Squarepublic struct Square{ ... public static explicit operator Square(int sideLength) { Square newSq = new Square {Length = sideLength}; return newSq; } public static explicit operator int (Square s) => s.Length;}По правде говоря, преобразование
SquareintТаким образом, как и с перегрузкой операций, возможность создания операции явного приведения для заданного типа вовсе не означает необходимость ее создания. Обычно этот прием будет наиболее полезным при создании типов структур, учитывая, что они не могут принимать участие в классическом наследовании (где приведение обеспечивается автоматически).
Определение процедур неявного преобразования
До сих пор мы создавали различные специальные операции явного преобразования. Но что насчет следующего неявного преобразования?
...Square s3 = new Square {Length = 83};// Попытка сделать неявное приведение?Rectangle rect2 = s3;Console.ReadLine();Данный код не скомпилируется, т.к. вы не предоставили процедуру неявного преобразования для типа
RectangleЗапутались? Чтобы прояснить ситуацию, давайте добавим к структуре
Rectangleimplicitpublic struct Rectangle{ ... public static implicit operator Rectangle(Square s) { Rectangle r = new Rectangle { Height = s.Length, Width = s.Length * 2 // Предположим, что ширина нового // квадрата будет равна (Length х 2).. }; return r; }}После такой модификации можно выполнять преобразование между типами:
...// Неявное преобразование работает!Square s3 = new Square { Length= 7};Rectangle rect2 = s3;Console.WriteLine("rect2 = {0}", rect2);// Синтаксис явного приведения также работает!Square s4 = new Square {Length = 3};Rectangle rect3 = (Rectangle)s4;Console.WriteLine("rect3 = {0}", rect3);Console.ReadLine();На этом обзор определения операций специального преобразования завершен. Как и с перегруженными операциями, помните о том, что данный фрагмент синтаксиса представляет собой просто сокращенное обозначение для "нормальных" функций-членов и потому всегда необязателен. Тем не менее, в случае правильного использования специальные структуры могут применяться более естественным образом, поскольку будут трактоваться как настоящие типы классов, связанные наследованием.
Понятие расширяющих методов
В версии .NET 3.5 появилась концепция расширяющих методов, которая позволила добавлять новые методы или свойства к классу либо структуре, не модифицируя исходный тип непосредственно. Когда такой прием может оказаться полезным? Рассмотрим следующие ситуации.
Пусть есть класс, находящийся в производстве. Со временем выясняется, что имеющийся класс должен поддерживать несколько новых членов. Изменение текущего определения класса напрямую сопряжено с риском нарушения обратной совместимости со старыми кодовыми базами, использующими его, т.к. они могут не скомпилироваться с последним улучшенным определением класса. Один из способов обеспечения обратной совместимости предусматривает создание нового класса, производного от существующего, но тогда придется сопровождать два класса. Как все мы знаем, сопровождение кода является самой скучной частью деятельности разработчика программного обеспечения.
Представим другую ситуацию. Предположим, что имеется структура (или, может быть, запечатанный класс), и необходимо добавить новые члены, чтобы получить полиморфное поведение в рамках системы. Поскольку структуры и запечатанные классы не могут быть расширены, единственный выбор заключается в том, чтобы добавить желаемые члены к типу, снова рискуя нарушить обратную совместимость!
За счет применения расширяющих методов появляется возможность модифицировать типы, не создавая подклассов и не изменяя код типа напрямую. Загвоздка в том, что новая функциональность предлагается типом, только если в текущем проекте будут присутствовать ссылки на расширяющие методы.
Определение расширяющих методов
Первое ограничение, связанное с расширяющими методами, состоит в том, что они должны быть определены внутри статического класса (см. главу 5), а потому каждый расширяющий метод должен объявляться с ключевым словом
staticthisthisВ целях иллюстрации создайте новый проект консольного приложения под названием
ExtensionMethodsМуExtensionsDisplayDefiningAssembly()System.ReflectionНа заметку! API-интерфейс рефлексии формально рассматривается в главе 17. Если эта тема для вас нова, тогда просто запомните, что рефлексия позволяет исследовать структуру сборок, типов и членов типов во время выполнения.
Второй расширяющий метод по имени
ReverseDigits()int1234ReverseDigits()4321System.Reflectionusing System;using System.Reflection;namespace MyExtensionMethods{ static class MyExtensions { // Этот метод позволяет объекту любого типа // отобразить сборку, в которой он определен public static void DisplayDefiningAssembly(this object obj) { Console.WriteLine("{0} lives here: => {1}\n", obj.GetType().Name, Assembly.GetAssembly(obj.GetType()).GetName().Name); } // Этот метод позволяет любому целочисленному значению изменить // порядок следования десятичных цифр на обратный. // Например, для 56 возвратится 65. public static int ReverseDigits(this int i) { // Транслировать int в string и затем получить все его символы. char[] digits = i.ToString().ToCharArray(); // Изменить порядок следования элементов массива. Array.Reverse(digits); // Поместить обратно в строку. string newDigits = new string(digits); // Возвратить модифицированную строку как int. return int.Parse(newDigits); } }}Снова обратите внимание на то, что первый параметр каждого расширяющего метода снабжен ключевым словом
thisDisplayDefiningAssembly()System.ObjectObjectReverseDigits()На заметку! Запомните, что каждый расширяющий метод может иметь множество параметров, но только первый параметр разрешено помечать посредством
thisВызов расширяющих методов
Располагая созданными расширяющими методами, рассмотрим следующий код, в котором они используются с разнообразными типами из библиотек базовых классов:
using System;using MyExtensionMethods;Console.WriteLine("***** Fun with Extension Methods *****\n");// В int появилась новая отличительная черта!int myInt = 12345678;myInt.DisplayDefiningAssembly();// И в SoundPlayer!System.Data.DataSet d = new System.Data.DataSet();d.DisplayDefiningAssembly();// Использовать новую функциональность int.Console.WriteLine("Value of myInt: {0}", myInt);Console.WriteLine("Reversed digits of myInt: {0}", myInt.ReverseDigits());Console.ReadLine();Ниже показан вывод:
***** Fun with Extension Methods *****Int32 lives here: => System.Private.CoreLibDataSet lives here: => System.Data.CommonValue of myInt: 12345678Reversed digits of myInt: 87654321 Импортирование расширяющих методов
Когда определяется класс, содержащий расширяющие методы, он вне всяких сомнений будет принадлежать какому-то пространству имен. Если это пространство имен отличается от пространства имен, где расширяющие методы применяются, тогда придется использовать ключевое слово
usingХотя на первый взгляд может показаться, что расширяющие методы глобальны по своей природе, на самом деле они ограничены пространствами имен, где определены, или пространствами имен, которые их импортируют. Вспомните, что вы поместили класс
MyExtensionsMyExtensionMethodsnamespace MyExtensionMethods{ static class MyExtensions { ... }}Для использования расширяющих методов класса
MyExtensionsMyExtensionMethodsРасширение типов, реализующих специфичные интерфейсы
К настоящему моменту вы видели, как расширять классы (и косвенно структуры, которые следуют тому же синтаксису) новой функциональностью через расширяющие методы. Также есть возможность определить расширяющий метод, который способен расширять только класс или структуру, реализующую корректный интерфейс. Например, можно было бы заявить следующее: если класс или структура реализует интерфейс
IEnumerableВ качестве примера создайте новый проект консольного приложения по имени
InterfaceExtensionsIEnumerableIEnumerableIEnumerableusing System;namespace InterfaceExtensions{ static class AnnoyingExtensions { public static void PrintDataAndBeep( this System.Collections.IEnumerable iterator) { foreach (var item in iterator) { Console.WriteLine(item); Console.Beep(); } } }}Поскольку метод
PrintDataAndBeep()IEnumerableusing System;using System.Collections.Generic;using InterfaceExtensions;Console.WriteLine("***** Extending Interface Compatible Types *****\n");// System.Array реализует IEnumerable!string[] data = { "Wow", "this", "is", "sort", "of", "annoying", "but", "in", "a", "weird", "way", "fun!"};data.PrintDataAndBeep();Console.WriteLine();// List реализует IEnumerable! List myInts = new List() {10, 15, 20}; myInts.PrintDataAndBeep();Console.ReadLine();На этом исследование расширяющих методов C# завершено. Помните, что данное языковое средство полезно, когда необходимо расширить функциональность типа, но вы не хотите создавать подклассы (или не можете, если тип запечатан) в целях обеспечения полиморфизма. Как вы увидите позже, расширяющие методы играют ключевую роль в API-интерфейсах LINQ. На самом деле вы узнаете, что в API-интерфейсах LINQ одним из самых часто расширяемых элементов является класс или структура, реализующая обобщенную версию интерфейса
IEnumerableПоддержка расширяющего метода GetEnumerator() (нововведение в версии 9.0)
До выхода версии C# 9.0 для применения оператора
foreachGetEnumerator()foreachGetEnumerator()IEnumeratorForEachWithExtensionMethodsCarGarage// Car.csusing System;namespace ForEachWithExtensionMethods{ class Car { // Свойства класса Car. public int CurrentSpeed {get; set;} = 0; public string PetName {get; set;} = ""; // Конструкторы. public Car() {} public Car(string name, int speed) { CurrentSpeed = speed; PetName = name; } // Выяснить, не перегрелся ли двигатель Car. }}// Garage.csnamespace ForEachWithExtensionMethods{ class Garage { public Car[] CarsInGarage { get; set; } // При запуске заполнить несколькими объектами Car. public Garage() { CarsInGarage = new Car[4]; CarsInGarage[0] = new Car("Rusty", 30); CarsInGarage[1] = new Car("Clunker", 55); CarsInGarage[2] = new Car("Zippy", 30); CarsInGarage[3] = new Car("Fred", 30); } }}Обратите внимание, что класс
GarageIEnumerableGetEnumerator()GetEnumerator()GarageExtensionsnamespace ForEachWithExtensionMethods{ static class GarageExtensions { public static IEnumerator GetEnumerator(this Garage g) => g.CarsInGarage.GetEnumerator(); }}Код для тестирования этого нового средства будет таким же, как код, который применялся для тестирования метода
GetEnumerator()Program.csusing System;using ForEachWithExtensionMethods;Console.WriteLine("***** Support for Extension Method GetEnumerator *****\n");Garage carLot = new Garage();// Проход по всем объектам Car в коллекции?foreach (Car c in carLot){ Console.WriteLine("{0} is going {1} MPH", c.PetName, c.CurrentSpeed);}Вы увидите, что код работает, успешно выводя на консоль список объектов автомобилей и скоростей их движения:
***** Support for Extension Method GetEnumerator *****Rusty is going 30 MPHClunker is going 55 MPHZippy is going 30 MPHFred is going 30 MPHНа заметку! Потенциальный недостаток нового средства заключается в том, что теперь с оператором
foreachПонятие анонимных типов
Программистам на объектно-ориентированных языках хорошо известны преимущества определения классов для представления состояния и функциональности заданного элемента, который требуется моделировать. Всякий раз, когда необходимо определить класс, предназначенный для многократного применения и предоставляющий обширную функциональность через набор методов, событий, свойств и специальных конструкторов, устоявшаяся практика предусматривает создание нового класса С#.
Тем не менее, возникают и другие ситуации, когда желательно определять класс просто в целях моделирования набора инкапсулированных (и каким-то образом связанных) элементов данных безо всяких ассоциированных методов, событий или другой специализированной функциональности. Кроме того, что если такой тип должен использоваться только небольшим набором методов внутри программы? Было бы довольно утомительно строить полное определение класса вроде показанного ниже, если хорошо известно, что класс будет применяться только в нескольких местах. Чтобы подчеркнуть данный момент, вот примерный план того, что может понадобиться делать, когда нужно создать "простой" тип данных, который следует обычной семантике на основе значений:
class SomeClass{// Определить набор закрытых переменных-членов...// Создать свойство для каждой закрытой переменной-члена...// Переопределить метод ToStringO для учета основных// переменных-членов...// Переопределить методы GetHashCode() и Equals() для работы// с эквивалентностью на основе значений...}Как видите, задача не обязательно оказывается настолько простой. Вам потребуется не только написать большой объем кода, но еще и сопровождать дополнительный класс в системе. Для временных данных подобного рода было бы удобно формировать специальный тип на лету. Например, пусть необходимо построить специальный метод, который принимает какой-то набор входных параметров.Такие параметры нужно использовать для создания нового типа данных, который будет применяться внутри области действия метода. Вдобавок желательно иметь возможность быстрого вывода данных с помощью метода
ToString()System.ObjectОпределение анонимного типа
Анонимный тип определяется с использованием ключевого слова
vavarВ целях иллюстрации создайте новый проект консольного приложения по имени
AnonymousTypesProgramstatic void BuildAnonymousType( string make, string color, int currSp ){ // Построить анонимный тип с применением входных аргументов. var car = new { Make = make, Color = color, Speed = currSp }; // Обратите внимание, что теперь этот тип можно // использовать для получения данных свойств! Console.WriteLine("You have a {0} {1} going {2} MPH", car.Color, car.Make, car.Speed); // Анонимные типы имеют специальные реализации каждого // виртуального метода System.Object. Например: Console.WriteLine("ToString() == {0}", car.ToString());}Обратите внимание, что помимо помещения кода внутрь функции анонимный тип можно также создавать непосредственно в строке:
Console.WriteLine("***** Fun with Anonymous Types *****\n");// Создать анонимный тип, представляющий автомобиль.var myCar = new { Color = "Bright Pink", Make = "Saab", CurrentSpeed = 55 };// Вывести на консоль цвет и производителя.Console.WriteLine("My car is a {0} {1}.", myCar.Color, myCar.Make);// Вызвать вспомогательный метод для построения// анонимного типа с указанием аргументов.BuildAnonymousType("BMW", "Black", 90);Console.ReadLine();В настоящий момент достаточно понимать, что анонимные типы позволяют быстро моделировать "форму" данных с небольшими накладными расходами. Они являются лишь способом построения на лету нового типа данных, который поддерживает базовую инкапсуляцию через свойства и действует в соответствии с семантикой на основе значений. Чтобы уловить суть последнего утверждения, давайте посмотрим, каким образом компилятор C# строит анонимные типы на этапе компиляции, и в особенности — как он переопределяет члены
System.ObjectВнутреннее представление анонимных типов
Все анонимные типы автоматически наследуются от
System.ObjectToString()GetHashCode()Equals()GetType()myCarProgramstatic void ReflectOverAnonymousType(object obj){ Console.WriteLine("obj is an instance of: {0}", obj.GetType().Name); Console.WriteLine("Base class of {0} is {1}", obj.GetType().Name, obj.GetType().BaseType); Console.WriteLine("obj.ToString() == {0}", obj.ToString()); Console.WriteLine("obj.GetHashCode() == {0}", obj.GetHashCode()); Console.WriteLine();}Пусть вы вызвали метод
ReflectOverAnonymousType()myCarConsole.WriteLine("***** Fun with Anonymous Types *****\n");// Создать анонимный тип, представляющий автомобиль.var myCar = new {Color = "Bright Pink", Make = "Saab", CurrentSpeed = 55};// Выполнить рефлексию того, что сгенерировал компилятор.ReflectOverAnonymousType(myCar);...Console.ReadLine();Вывод будет выглядеть примерно так:
***** Fun with Anonymous Types *****obj is an instance of: <>f__AnonymousType0`3Base class of <>f__AnonymousType0`3 is System.Objectobj.ToString() = { Color = Bright Pink, Make = Saab, CurrentSpeed = 55 }obj.GetHashCode() = -564053045Первым делом обратите внимание в примере на то, что объект
myCar<>f__AnonymousType0`3Пожалуй, наиболее важно здесь то, что каждая пара "имя-значение", определенная с использованием синтаксиса инициализации объектов, отображается на идентично именованное свойство, доступное только для чтения, и соответствующее закрытое поддерживающее поле, которое допускает только инициализацию. Приведенный ниже код C# приблизительно отражает сгенерированный компилятором класс, применяемый для представления объекта
myCarildasm.exeprivate sealed class <>f__AnonymousType0'3'<'j__TPar', 'j__TPar', j__TPar>' extends [System.Runtime][System.Object]{ // Поля только для инициализации. private initonly j__TPar i__Field; private initonly j__TPar i__Field; private initonly j__TPar i__Field; // Стандартный конструктор. public <>f__AnonymousType0(j__TPar Color, j__TPar Make, j__TPar CurrentSpeed); // Переопределенные методы. public override bool Equals(object value); public override int GetHashCode(); public override string ToString(); // Свойства только для чтения. j__TPar Color { get; } j__TPar CurrentSpeed { get; } j__TPar Make { get; } }Реализация методов ToString() и GetHashCode()
Все анонимные типы автоматически являются производными от
System.ObjectEquals()GetHashCode()ToString()ToString()public override string ToString(){ StringBuilder builder = new StringBuilder(); builder.Append("{ Color = "); builder.Append(this.i__Field); builder.Append(", Make = "); builder.Append(this.i__Field); builder.Append(", CurrentSpeed = "); builder.Append(this.i__Field); builder.Append(" }"); return builder.ToString();}Реализация
GetHashCode()System.Collections.Generic.EqualityComparerGetHashCode()HashtableСемантика эквивалентности анонимных типов
Наряду с тем, что реализация переопределенных методов
ToString()GetHashCode()Equals()Programstatic void EqualityTest(){ // Создать два анонимных класса с идентичными наборами // пар "имя-значение". var firstCar = new { Color = "Bright Pink", Make = "Saab", CurrentSpeed = 55 }; var secondCar = new { Color = "Bright Pink", Make = "Saab", CurrentSpeed = 55 }; // Считаются ли они эквивалентными, когда используется Equals()? if (firstCar.Equals(secondCar)) { Console.WriteLine("Same anonymous object!"); // Тот же самый анонимный объект } else { Console.WriteLine("Not the same anonymous object!"); // He тот же самый анонимный объект } // Можно ли проверить их эквивалентность с помощью операции ==? if (firstCar == secondCar) { Console.WriteLine("Same anonymous object!"); // Тот же самый анонимный объект } else { Console.WriteLine("Not the same anonymous object!"); // He тот же самый анонимный объект } // Имеют ли эти объекты в основе один и тот же тип? if (firstCar.GetType().Name == secondCar.GetType().Name) { Console.WriteLine("We are both the same type!"); // Оба объекта имеют тот же самый тип } else { Console.WriteLine("We are different types!"); // Объекты относятся к разным типам } // Отобразить все детали. Console.WriteLine(); ReflectOverAnonymousType(firstCar); ReflectOverAnonymousType(secondCar);}В результате вызова метода
EqualityTest()My car is a Bright Pink Saab.You have a Black BMW going 90 MPHToString() == { Make = BMW, Color = Black, Speed = 90 }Same anonymous object!Not the same anonymous object!We are both the same type!obj is an instance of: <>f__AnonymousType0`3Base class of <>f__AnonymousType0`3 is System.Objectobj.ToString() == { Color = Bright Pink, Make = Saab, CurrentSpeed = 55 }obj.GetHashCode() == -925496951obj is an instance of: <>f__AnonymousType0`3Base class of <>f__AnonymousType0`3 is System.Objectobj.ToString() == { Color = Bright Pink, Make = Saab, CurrentSpeed = 55 }obj.GetHashCode() == -925496951Как видите, первая проверка, где вызывается
Equals()trueSame anonymous object!Equals()Тем не менее, вторая проверка, в которой используется операция
==Not the same anonymous object!==!=Equals()Наконец, в финальной проверке (где исследуется имя лежащего в основе типа) обнаруживается, что объекты анонимных типов являются экземплярами одного и того же типа класса, сгенерированного компилятором (
f__AnonymousType0`3firstCarsecondCarColorMakeCurrentSpeedЭто иллюстрирует важный, но тонкий аспект: компилятор будет генерировать новое определение класса, только когда анонимный тип содержит уникальные имена свойств. Таким образом, если вы объявляете идентичные анонимные типы (в смысле имеющие те же самые имена свойств) внутри сборки, то компилятор генерирует единственное определение анонимного типа.
Анонимные типы, содержащие другие анонимные типы
Можно создавать анонимные типы, которые состоят из других анонимных типов. В качестве примера предположим, что требуется смоделировать заказ на приобретение, который хранит метку времени, цену и сведения о приобретаемом автомобиле. Вот новый (чуть более сложный) анонимный тип, представляющий такую сущность:
// Создать анонимный тип, состоящий из еще одного анонимного типа.var purchaseItem = new { TimeBought = DateTime.Now, ItemBought = new {Color = "Red", Make = "Saab", CurrentSpeed = 55}, Price = 34.000};ReflectOverAnonymousType(purchaseItem);Сейчас вы уже должны понимать синтаксис, используемый для определения анонимных типов, но возможно все еще интересуетесь, где (и когда) применять такое языковое средство. Выражаясь кратко, объявления анонимных типов следует использовать умеренно, обычно только в случае применения набора технологий LINQ (см. главу 13). С учетом описанных ниже многочисленных ограничений анонимных типов вы никогда не должны отказываться от использования строго типизированных классов и структур просто из-за того, что это возможно.
• Контроль над именами анонимных типов отсутствует.
• Анонимные типы всегда расширяют
System.Object• Поля и свойства анонимного типа всегда допускают только чтение.
• Анонимные типы не могут поддерживать события, специальные методы, специальные операции или специальные переопределения.
• Анонимные типы всегда неявно запечатаны.
• Экземпляры анонимных типов всегда создаются с применением стандартных конструкторов.
Однако при программировании с использованием набора технологий LINQ вы обнаружите, что во многих случаях такой синтаксис оказывается удобным, когда нужно быстро смоделировать общую форму сущности, а не ее функциональность.
Работа с типами указателей
Последняя тема главы касается средства С#, которое в подавляющем большинстве проектов .NET Core применяется реже всех остальных.
На заметку! В последующих примерах предполагается наличие у вас определенных навыков манипулирования указателями в языке C++ . Если это не так, тогда можете спокойно пропустить данную тему. В большинстве приложений C# указатели не используются.
В главе 4 вы узнали, что в рамках платформы .NET Core определены две крупные категории данных: типы значений и ссылочные типы. По правде говоря, на самом деле есть еще и третья категория: типы указателей. Для работы с типами указателей доступны специфичные операции и ключевые слова (табл. 11.2), которые позволяют обойти схему управления памятью исполняющей среды .NET 5 и взять дело в свои руки.
Перед погружением в детали следует еще раз подчеркнуть, что вам очень редко, если вообще когда-нибудь, понадобится использовать типы указателей. Хотя C# позволяет опуститься на уровень манипуляций указателями, помните, что исполняющая среда .NET Core не имеет абсолютно никакого понятия о ваших намерениях. Соответственно, если вы неправильно управляете указателем, то сами и будете отвечать за последствия. С учетом этих предупреждений возникает вопрос: когда в принципе может возникнуть необходимость работы с типами указателей? Существуют две распространенные ситуации.
• Нужно оптимизировать избранные части приложения, напрямую манипулируя памятью за рамками ее управления со стороны исполняющей среды .NET 5.
• Необходимо вызывать методы из DLL-библиотеки, написанной на С, либо из сервера СОМ, которые требуют передачи типов указателей в качестве параметров. Но даже в таком случае часто можно обойтись без применения типов указателей, отдав предпочтение типу
System.IntPtrSystem.Runtime.InteropServices.MarshalЕсли вы решили задействовать данное средство языка С#, тогда придется информировать компилятор C# о своих намерениях, разрешив проекту поддерживать "небезопасный код". Создайте новый проект консольного приложения по имени
UnsafeCodeUnsafeCode.csproj true Для установки этого свойства в Visual Studio предлагается графический пользовательский интерфейс. Откройте окно свойств проекта. В раскрывающемся списке Configuration (Конфигурация) выберите вариант All Configurations (Все конфигурации), перейдите на вкладку Build (Сборка) и отметьте флажок Allow unsafe code (Разрешить небезопасный код), как показано на рис. 11.1.
Ключевое слово unsafe
Для работы с указателями в C# должен быть специально объявлен блок "небезопасного кода" с использованием ключевого слова
unsafeunsafeProgram.csusing System;using UnsafeCode;Console.WriteLine("***** Calling method with unsafe code *****");unsafe{ // Здесь работаем с указателями!}// Здесь работа с указателями невозможна!В дополнение к объявлению области небезопасного кода внутри метода можно строить "небезопасные" структуры, классы, члены типов и параметры. Ниже приведено несколько примеров (типы
NodeNode2// Эта структура целиком является небезопасной и может// использоваться только в небезопасном контексте.unsafe struct Node{ public int Value; public Node* Left; public Node* Right;}// Эта структура безопасна, но члены Node2* - нет.// Формально извне небезопасного контекста можно// обращаться к Value, но не к Left и Right.public struct Node2{ public int Value; // Эти члены доступны только в небезопасном контексте! public unsafe Node2* Left; public unsafe Node2* Right;}Методы (статические либо уровня экземпляра) также могут быть помечены как небезопасные. Предположим, что какой-то статический метод будет использовать логику указателей. Чтобы обеспечить возможность вызова данного метода только из небезопасного контекста, его можно определить так:
static unsafe void SquareIntPointer(int* myIntPointer){ // Возвести значение в квадрат просто для тестирования. *myIntPointer *= *myIntPointer;}Конфигурация метода требует, чтобы вызывающий код обращался к методу
SquareIntPointer()unsafe{ int myInt = 10; // Нормально, мы находимся в небезопасном контексте. SquareIntPointer(&myInt); Console.WriteLine("myInt: {0}", myInt);}int myInt2 = 5;// Ошибка на этапе компиляции!// Это должно делаться в небезопасном контексте!SquareIntPointer(&myInt2);Console.WriteLine("myInt: {0}", myInt2);Если вы не хотите вынуждать вызывающий код помещать такой вызов внутрь небезопасного контекста, то можете поместить все операторы верхнего уровня в блок
unsafeMain()Main()unsafestatic unsafe void Main(string[] args){ int myInt2 = 5; SquareIntPointer(&myInt2); Console.WriteLine("myInt: {0}", myInt2);}Запустив такую версию кода, вы получите следующий вывод:
myInt: 25На заметку! Важно отметить, что термин "небезопасный" был выбран небезосновательно. Прямой доступ к стеку и работа с указателями может приводить к неожиданным проблемам с вашим приложением, а также с компьютером, на котором оно функционирует. Если вам приходится иметь дело с небезопасным кодом, тогда будьте крайне внимательны.
Работа с операциями * и &
После установления небезопасного контекста можно строить указатели и типы данных с помощью операции
*&*// Нет! В C# это некорректно!int *pi, *pj;// Да! Так поступают в С#.int* pi, pj;Рассмотрим следующий небезопасный метод:
static unsafe void PrintValueAndAddress(){ int myInt; // Определить указатель на int и присвоить ему адрес myInt. int* ptrToMyInt = &myInt; // Присвоить значение myInt, используя обращение через указатель. *ptrToMyInt = 123; // Вывести некоторые значения. Console.WriteLine("Value of myInt {0}", myInt); // значение myInt Console.WriteLine("Address of myInt {0:X}", (int)&ptrToMyInt); // адрес myInt}В результате запуска этого метода из блока
unsafe**** Print Value And Address ****Value of myInt 123Address of myInt 90F7E698Небезопасная (и безопасная) функция обмена
Разумеется, объявлять указатели на локальные переменные, чтобы просто присваивать им значения (как в предыдущем примере), никогда не понадобится и к тому же неудобно. В качестве более практичного примера небезопасного кода предположим, что необходимо построить функцию обмена с использованием арифметики указателей:
unsafe static void UnsafeSwap(int* i, int* j){ int temp = *i; *i = *j; *j = temp;}Очень похоже на язык С, не так ли? Тем не менее, учитывая предшествующую работу, вы должны знать, что можно было бы написать безопасную версию алгоритма обмена с применением ключевого слова
refstatic void SafeSwap(ref int i, ref int j){ int temp = i; i = j; j = temp;}Функциональность обеих версий метода идентична, доказывая тем самым, что прямые манипуляции указателями в C# не являются обязательными. Ниже показана логика вызова, использующая безопасные операторы верхнего уровня, но с небезопасным контекстом:
Console.WriteLine("***** Calling method with unsafe code *****");// Значения, подлежащие обмену.int i = 10, j = 20;// "Безопасный" обмен значений местами.Console.WriteLine("\n***** Safe swap *****");Console.WriteLine("Values before safe swap: i = {0}, j = {1}", i, j);SafeSwap(ref i, ref j);Console.WriteLine("Values after safe swap: i = {0}, j = {1}", i, j);// "Небезопасный" обмен значений местами.Console.WriteLine("\n***** Unsafe swap *****");Console.WriteLine("Values before unsafe swap: i = {0}, j = {1}", i, j);unsafe { UnsafeSwap(&i, &j); }Console.WriteLine("Values after unsafe swap: i = {0}, j = {1}", i, j);Console.ReadLine();Доступ к полям через указатели (операция ->)
Теперь предположим, что определена простая безопасная структура
Pointstruct Point{ public int x; public int y; public override string ToString() => $"({x}, {y})"; } В случае объявления указателя на тип
Point->.*static unsafe void UsePointerToPoint(){ // Доступ к членам через указатель. Point; Point* p = &point; p->x = 100; p->y = 200; Console.WriteLine(p->ToString()); // Доступ к членам через разыменованный указатель. Point point2; Point* p2 = &point2; (*p2).x = 100; (*p2).y = 200; Console.WriteLine((*p2).ToString());}Ключевое слово stackalloc
В небезопасном контексте может возникнуть необходимость в объявлении локальной переменной, для которой память выделяется непосредственно в стеке вызовов (и потому она не обрабатывается сборщиком мусора .NET Core). Для этого в языке C# предусмотрено ключевое слово
stackalloc_аllосаstatic unsafe string UnsafeStackAlloc(){ char* p = stackalloc char[52]; for (int k = 0; k < 52; k++) { p[k] = (char)(k + 65)k; } return new string(p);} Закрепление типа посредством ключевого слова fixed
В предыдущем примере вы видели, что выделение фрагмента памяти внутри небезопасного контекста может делаться с помощью ключевого слова
stackallocstackalloc->PointPointclass PointRef // <= Renamed and retyped.{ public int x; public int y; public override string ToString() => $"({x}, {y})";}Как вам известно, если в вызывающем коде объявляется переменная типа
PointPointДля фиксации переменной ссылочного типа в памяти из небезопасного контекста язык C# предлагает ключевое слово
fixedfixedfixedfixedТаким образом, если вы создали объект
Pointunsafe static void UseAndPinPoint(){ PointRef pt = new PointRef { x = 5, y = 6 }; // Закрепить указатель pt на месте, чтобы он не мог // быть перемещен или уничтожен сборщиком мусора. fixed (int* p = &pt.x) { // Использовать здесь переменную int*! } // Указатель pt теперь не закреплен и готов // к сборке мусора после завершения метода. Console.WriteLine ("Point is: {0}", pt);}Выражаясь кратко, ключевое слово
fixedКлючевое слово sizeof
Последнее ключевое слово С#, связанное с небезопасным кодом —
sizeofsizeofsizeofstatic void UseSizeOfOperator(){ Console.WriteLine("The size of short is {0}.", sizeof(short)); Console.WriteLine("The size of int is {0}.", sizeof(int)); Console.WriteLine("The size of long is {0}.", sizeof(long));}Тем не менее, если вы хотите получить размер специальной структуры
PointUseSizeOfOperator()unsafeunsafe static void UseSizeOfOperator(){ ... unsafe { Console.WriteLine("The size of Point is {0}.", sizeof(Point)); }}Итак, обзор нескольких более сложных средств языка программирования C# завершен. Напоследок снова необходимо отметить, что в большинстве проектов .NET эти средства могут вообще не понадобиться (особенно указатели). Тем не менее, как будет показано в последующих главах, некоторые средства действительно полезны (и даже обязательны) при работе с API-интерфейсами LINQ, в частности расширяющие методы и анонимные типы.
Резюме
Целью главы было углубление знаний языка программирования С#. Первым делом мы исследовали разнообразные более сложные конструкции в типах (индексаторные методы, перегруженные операции и специальные процедуры преобразования).
Затем мы рассмотрели роль расширяющих методов и анонимных типов. Как вы увидите в главе 13, эти средства удобны при работе с API-интерфейсами LINQ (хотя при желании их можно применять в коде повсеместно). Вспомните, что анонимные методы позволяют быстро моделировать "форму" типа, в то время как расширяющие методы дают возможность добавлять новую функциональность к типам без необходимости в определении подклассов.
Финальная часть главы была посвящена небольшому набору менее известных ключевых слов (
sizeofunsafeГлава 12 Делегаты, события и лямбда-выражения
Вплоть до настоящего момента в большинстве разработанных приложений к операторам верхнего уровня внутри файла
Program.csВ рамках платформы .NET Core предпочтительным средством определения и реагирования на обратные вызовы в приложении является тип делегата. По существу тип делегата .NET Core — это безопасный в отношении типов объект, "указывающий" на метод или список методов, которые могут быть вызваны позднее. Тем не менее, в отличие от традиционного указателя на функцию C++ делегаты представляют собой классы, которые обладают встроенной поддержкой группового и асинхронного вызова методов.
На заметку! В предшествующих версиях .NET делегаты обеспечивали вызов асинхронных методов с помощью
BeginInvoke()/EndInvoke()BeginInvoke()/EndInvoke()IAsyncResultBeginInvoke()/EndInvoke()В текущей главе вы узнаете, каким образом создавать и манипулировать типами делегатов, а также использовать ключевое слово event языка С#, которое облегчает работу с типами делегатов. По ходу дела вы также изучите несколько языковых средств С#, ориентированных на делегаты и события, в том числе анонимные методы и групповые преобразования методов.
Глава завершается исследованием лямбда-выражений. С помощью лямбда-операции C# (
=>Понятие типа делегата
Прежде чем формально определить делегаты, давайте ненадолго оглянемся назад. Исторически сложилось так, что в API-интерфейсе Windows часто использовались указатели на функции в стиле С для создания сущностей под названием функции обратного вызова или просто обратные вызовы. С помощью обратных вызовов программисты могли конфигурировать одну функцию так, чтобы она обращалась к другой функции в приложении (т.е. делала обратный вызов). С применением такого подхода разработчики Windows-приложений имели возможность обрабатывать щелчки на кнопках, перемещение курсора мыши, выбор пунктов меню и общие двусторонние коммуникации между двумя сущностями в памяти.
В .NET и .NET Core обратные вызовы выполняются в безопасной в отношении типов объектно-ориентированной манере с использованием делегатов. Делегат — это безопасный в отношении типов объект, указывающий на другой метод или возможно на список методов приложения, которые могут быть вызваны в более позднее время.
В частности, делегат поддерживает три важных порции информации:
• адрес метода, вызовы которого он делает:
• аргументы (если есть) вызываемого метода:
• возвращаемое значение (если есть) вызываемого метода.
На заметку! Делегаты .NET Core могут указывать либо на статические методы, либо на методы экземпляра.
После того как делегат создан и снабжен необходимой информацией, он может во время выполнения динамически вызывать метод или методы, на которые указывает.
Определение типа делегата в C#
Для определения типа делегата в языке C# применяется ключевое слово
delegateBinaryOp// Этот делегат может указывать на любой метод, который принимает// два целочисленных значения и возвращает целочисленное значение.public delegate int BinaryOp(int x, int y);Когда компилятор C# обрабатывает тип делегата, он автоматически генерирует запечатанный (
sealedSystem.MulticastDelegateSystem.DelegateBinaryOpildasm.exe// -------------------------------------------------------// TypDefName: SimpleDelegate.BinaryOp// Extends : System.MulticastDelegate// Method #1// -------------------------------------------------------// MethodName: .ctor// ReturnType: Void// 2 Arguments// Argument #1: Object// Argument #2: I// Method #2// -------------------------------------------------------// MethodName: Invoke// ReturnType: I4// 2 Arguments// Argument #1: I4// Argument #2: I4// 2 Parameters// (1) ParamToken : Name : x flags: [none]// (2) ParamToken : Name : y flags: [none] //// Method #3// -------------------------------------------------------// MethodName: BeginInvoke// ReturnType: Class System.IAsyncResult// 4 Arguments// Argument #1: I4// Argument #2: I4// Argument #3: Class System.AsyncCallback// Argument #4: Object// 4 Parameters// (1) ParamToken : Name : x flags: [none]// (2) ParamToken : Name : y flags: [none]// (3) ParamToken : Name : callback flags: [none]// (4) ParamToken : Name : object flags: [none]//// Method #4// -------------------------------------------------------// MethodName: EndInvoke// ReturnType: I4 (int32)// 1 Arguments// Argument #1: Class System.IAsyncResult// 1 Parameters// (1) ParamToken : Name : result flags: [none]Как видите, в сгенерированном компилятором классе
BinaryOpInvoke()Invoke()Invoke()На заметку! Несмотря на то что методы
BeginInvoke()EndInvoke()Так благодаря чему же компилятор знает, как определять метод
Invoke()BinaryOpsealed class BinaryOp : System.MulticastDelegate{ public int Invoke(int x, int y);...}Первым делом обратите внимание, что параметры и возвращаемый тип для метода
Invoke()BinaryOpДавайте рассмотрим еще один пример. Предположим, что определен тип делегата, который может указывать на любой метод, возвращающий значение
stringSystem.Booleanpublic delegate string MyDelegate (bool a, bool b, bool c);На этот раз сгенерированный компилятором класс можно представить так:
sealed class MyDelegate : System.MulticastDelegate{ public string Invoke(bool a, bool b, bool c);...}Делегаты могут также "указывать" на методы, которые содержат любое количество параметров
outrefparamspublic delegate string MyOtherDelegate(out bool a, ref bool b, int c);Сигнатура метода
Invoke()Подводя итоги, отметим, что определение типа делегата C# дает в результате запечатанный класс со сгенерированным компилятором методом, в котором типы параметров и возвращаемые типы основаны на объявлении делегата. Базовый шаблон может быть приближенно описан с помощью следующего псевдокода:
// Это лишь псевдокод!public sealed class ИмяДелегата : System.MulticastDelegate{ public возвращаемоеЗначениеДелегата Invoke(всеВходныеRefиOutПараметрыДелегата);}Базовые классы System.MulticastDelegate и System.Delegate
Итак, когда вы строите тип с применением ключевого слова
delegateSystem.MulticastDelegateSystem.MulticastDelegatepublic abstract class MulticastDelegate : Delegate{ // Возвращает список методов, на которые "указывает" делегат. public sealed override Delegate[] GetInvocationList(); // Перегруженные операции. public static bool operator == (MulticastDelegate d1, MulticastDelegate d2); public static bool operator != (MulticastDelegate d1, MulticastDelegate d2); // Используются внутренне для управления списком методов, // поддерживаемых делегатом. private IntPtr _invocationCount; private object _invocationList;}Класс
System.MulticastDelegateSystem.Delegatepublic abstract class Delegate : ICloneable, ISerializable{ // Методы для взаимодействия со списком функций. public static Delegate Combine(params Delegate[] delegates); public static Delegate Combine(Delegate a, Delegate b); public static Delegate Remove( Delegate source, Delegate value); public static Delegate RemoveAll( Delegate source, Delegate value); // Перегруженные операции. public static bool operator ==(Delegate d1, Delegate d2); public static bool operator !=(Delegate d1, Delegate d2); // Свойства, открывающие доступ к цели делегата. public MethodInfo Method { get; } public object Target { get; }}Имейте в виду, что вы никогда не сможете напрямую наследовать от таких базовых классов в своем коде (попытка наследования приводит к ошибке на этапе компиляции). Тем не менее, когда вы используете ключевое слово
delegateMulticastDelegate
Пример простейшего делегата
На первый взгляд делегаты могут показаться несколько запутанными. Рассмотрим для начала простой проект консольного приложения (по имени
SimpleDelegateBinaryOp// SimpleMath.csnamespace SimpleDelegate{ // Этот класс содержит методы, на которые // будет указывать BinaryOp. public class SimpleMath { public static int Add(int x, int y) => x + y; public static int Subtract(int x, int y) => x - y; }}// Program.csusing System;using SimpleDelegate;Console.WriteLine("***** Simple Delegate Example *****\n");// Создать объект делегата BinaryOp, который// "указывает" на SimpleMath.Add().BinaryOp b = new BinaryOp(SimpleMath.Add);// Вызвать метод Add() косвенно с использованием объекта делегата.Console.WriteLine("10 + 10 is {0}", b(10, 10));Console.ReadLine();// Дополнительные определения типов должны находиться// в конце операторов верхнего уровня.// Этот делегат может указывать на любой метод,// принимающий два целых числа и возвращающий целое число.public delegate int BinaryOp(int x, int y);На заметку! Вспомните из главы 3, что дополнительные определения типов (делегат
BinaryOpИ снова обратите внимание на формат объявления типа делегата
BinaryOpBinaryOpSimpleMathinaryOpКогда вы хотите присвоить целевой метод заданному объекту делегата, просто передайте имя нужного метода конструктору делегата:
// Создать объект делегата BinaryOp, который// "указывает" на SimpleMath.Add().BinaryOp b = new BinaryOp(SimpleMath.Add);На данной стадии метод, на который указывает делегат, можно вызывать с использованием синтаксиса, выглядящего подобным прямому вызову функции:
// На самом деле здесь вызывается метод Invoke()!Console.WriteLine("10 + 10 is {0}", b(10, 10));"За кулисами" исполняющая среда вызывает сгенерированный компилятором метод
Invoke()MulticastDelegateildasm.exeMain().method private hidebysig static void Main(string[] args) cil managed{ ... callvirt instance int32 BinaryOp::Invoke(int32, int32)}Язык C# вовсе не требует явного вызова метода
Invoke()BinaryOpConsole.WriteLine("10 + 10 is {0}", b.Invoke(10, 10));Вспомните, что делегаты .NET Core безопасны в отношении типов. Следовательно, если вы попытаетесь передать делегату метод, который не соответствует его шаблону, то получите ошибку на этапе компиляции. В целях иллюстрации предположим, что в классе
SimpleMathSquareNumber()public class SimpleMath{ public static int SquareNumber(int a) => a * a;}Учитывая, что делегат
BinaryOp// Ошибка на этапе компиляции! Метод не соответствует шаблону делегата!BinaryOp b2 = new BinaryOp(SimpleMath.SquareNumber);Исследование объекта делегата
Давайте усложним текущий пример, создав в классе
ProgramDisplayDelegatelnfо()System.DelegateGetlnvocationList()TargetMethodstatic void DisplayDelegateInfo(Delegate delObj){ // Вывести имена всех членов в списке вызовов делегата. foreach (Delegate d in delObj.GetInvocationList()) { Console.WriteLine("Method Name: {0}", d.Method); // имя метода Console.WriteLine("Type Name: {0}", d.Target); // имя типа }}Предполагая, что в метод
Main()BinaryOp b = new BinaryOp(SimpleMath.Add);DisplayDelegateInfo(b);вывод приложения будет таким:
***** Simple Delegate Example *****Method Name: Int32 Add(Int32, Int32)Type Name:10 + 10 is 20Обратите внимание, что при обращении к свойству
TargetSimpleMathBinaryOpAdd()Substract()staticSimpleMatusing System;using SimpleDelegate;Console.WriteLine("***** Simple Delegate Example *****\n");// Делегаты могут также указывать на методы экземпляра.SimpleMath m = new SimpleMath();BinaryOp b = new BinaryOp(m.Add);// Вывести сведения об объекте.DisplayDelegateInfo(b);Console.WriteLine("10 + 10 is {0}", b(10, 10));Console.ReadLine();В данном случае вывод будет выглядеть следующим образом:
***** Simple Delegate Example *****Method Name: Int32 Add(Int32, Int32)Type Name: SimpleDelegate.SimpleMath10 + 10 is 20Отправка уведомлений о состоянии объекта с использованием делегатов
Очевидно, что предыдущий пример
SimpleDelegateCar1. Определить новый тип делегата, который будет использоваться для отправки уведомлений вызывающему коду.
2. Объявить переменную-член этого типа делегата в классе
Car3. Создать в классе
Car4. Реализовать метод
Accelerate()Для начала создайте новый проект консольного приложения по имени
CarDelegateCarusing System;using System.Linq;namespace CarDelegate{ public class Car { // Внутренние данные состояния. public int CurrentSpeed { get; set; } public int MaxSpeed { get; set; } = 100; public string PetName { get; set; } // Исправен ли автомобиль? private bool _carIsDead; // Конструкторы класса. public Car() {} public Car(string name, int maxSp, int currSp) { CurrentSpeed = currSp; MaxSpeed = maxSp; PetName = name; } }}А теперь модифицируйте его, выполнив первые три действия из числа указанных выше:
public class Car{ ... // 1. Определить тип делегата. public delegate void CarEngineHandler(string msgForCaller); // 2. Определить переменную-член этого типа делегата. private CarEngineHandler _listOfHandlers; // 3. Добавить регистрационную функцию для вызывающего кода. public void RegisterWithCarEngine(CarEngineHandler methodToCall) { _listOfHandlers = methodToCall; }}В приведенном примере обратите внимание на то, что типы делегатов определяются прямо внутри области действия класса
CarCarEngineHandlerstringvoidКроме того, была объявлена закрытая переменная-член делегата (
_listOfHandlersRegisterWithCarEngine()На заметку! Строго говоря, переменную-член типа делегата можно было бы определить как
publicprivateТеперь необходимо создать метод
Accelerate()Car// 4. Реализовать метод Accelerate() для обращения к списку// вызовов делегата в подходящих обстоятельствах.public void Accelerate(int delta){ /// Если этот автомобиль сломан, то отправить сообщение об этом. if (_carIsDead) { _listOfHandlers?.Invoke("Sorry, this car is dead..."); } else { CurrentSpeed += delta; // Автомобиль почти сломан? if (10 == (MaxSpeed - CurrentSpeed)) { _listOfHandlers?.Invoke("Careful buddy! Gonna blow!"); } if (CurrentSpeed >= MaxSpeed) { _carIsDead = true; } else { Console.WriteLine("CurrentSpeed = {0}", CurrentSpeed); } }}Обратите внимание, что при попытке вызова методов, поддерживаемых переменной-членом
_listOfHandlersnullRegisterWithCarEngine()RegisterWithCarEngine()NullReferenceExceptionProgram.csusing System;using CarDelegate;Console.WriteLine("** Delegates as event enablers **\n");// Создать объект Car.Car c1 = new Car("SlugBug", 100, 10);// Сообщить объекту Car, какой метод вызывать,// когда он пожелает отправить сообщение.c1.RegisterWithCarEngine( new Car.CarEngineHandler(OnCarEngineEvent));// Увеличить скорость (это инициирует события).Console.WriteLine("***** Speeding up *****");for (int i = 0; i < 6; i++){ c1.Accelerate(20);}Console.ReadLine();// Цель для входящих сообщений.static void OnCarEngineEvent(string msg){ Console.WriteLine("\n*** Message From Car Object ***"); Console.WriteLine("=> {0}", msg); Console.WriteLine("********************\n");}Код начинается с создания нового объекта
CarRegisterWithCarEngine()RegisterWithCarEngine()CarEngineHandlerProgramOnCarEngineEvent()stringvoid***** Delegates as event enablers ********** Speeding up *****CurrentSpeed = 30CurrentSpeed = 50CurrentSpeed = 70***** Message From Car Object *****=> Careful buddy! Gonna blow!***********************************CurrentSpeed = 90***** Message From Car Object *****=> Sorry, this car is dead...***********************************Включение группового вызова
Вспомните, что делегаты .NET Core обладают встроенной возможностью группового вызова. Другими словами, объект делегата может поддерживать целый список методов для вызова, а не просто единственный метод. Для добавления нескольких методов к объекту делегата вместо прямого присваивания применяется перегруженная операция
+=CarRegisterWithCarEngine()public class Car{ // Добавление поддержки группового вызова. // Обратите внимание на использование операции +=, // а не обычной операции присваивания (=). public void RegisterWithCarEngine( CarEngineHandler methodToCall) { _listOfHandlers += methodToCall; } ...}Когда операция
+=Delegate.Combine()Delegate.Combine()+=RegisterWithCarEngine()Delegate.Combine()+=public void RegisterWithCarEngine( CarEngineHandler methodToCall ){ if (_listOfHandlers == null) { _listOfHandlers = methodToCall; } else { _listOfHandlers = Delegate.Combine(_listOfHandlers, methodToCall) as CarEngineHandler; }}В любом случае вызывающий код теперь может регистрировать множественные цели для одного и того же обратного вызова. Второй обработчик выводит входное сообщение в верхнем регистре просто ради отображения:
Console.WriteLine("***** Delegates as event enablers *****\n");// Создать объект Car.Car c1 = new Car("SlugBug", 100, 10);// Зарегистрировать несколько обработчиков событий.c1.RegisterWithCarEngine( new Car.CarEngineHandler(OnCarEngineEvent));c1.RegisterWithCarEngine( new Car.CarEngineHandler(OnCarEngineEvent2));// Увеличить скорость (это инициирует события).Console.WriteLine("***** Speeding up *****");for (int i = 0; i < 6; i++){ c1.Accelerate(20);}Console.ReadLine();// Теперь есть ДВА метода, которые будут// вызываться Car при отправке уведомлений.static void OnCarEngineEvent(string msg){ Console.WriteLine("\n*** Message From Car Object ***"); Console.WriteLine("=> {0}", msg); Console.WriteLine("*********************************\n");}static void OnCarEngineEvent2(string msg){ Console.WriteLine("=> {0}", msg.ToUpper());}Удаление целей из списка вызовов делегата
В классе
DelegateRemove()Delegate.Remove()-=Carpublic class Car{ ... public void UnRegisterWithCarEngine(CarEngineHandler methodToCall) { _listOfHandlers -= methodToCall; }}При таком обновлении класса
CarConsole.WriteLine("***** Delegates as event enablers *****\n");// Создать объект Car.Car c1 = new Car("SlugBug", 100, 10);c1.RegisterWithCarEngine( new Car.CarEngineHandler(OnCarEngineEvent));// На этот раз сохранить объект делегата, чтобы позже// можно было отменить регистрацию.Car.CarEngineHandler handler2 = new Car.CarEngineHandler(OnCarEngineEvent2);c1.RegisterWithCarEngine(handler2);// Увеличить скорость (это инициирует события).Console.WriteLine("***** Speeding up *****");for (int i = 0; i < 6; i++){ c1.Accelerate(20);}// Отменить регистрацию второго обработчика.c1.UnRegisterWithCarEngine(handler2);// Сообщения в верхнем регистре больше не выводятся.Console.WriteLine("***** Speeding up *****");for (int i = 0; i < 6; i++){ c1.Accelerate(20);}Console.ReadLine();Отличие этого кода в том, что здесь создается объект
Car.CarEngineHandlerCarСинтаксис групповых преобразований методов
В предыдущем примере
CarDelegateCar.CarEngineHandlerConsole.WriteLine("***** Delegates as event enablers *****\n");Car c1 = new Car("SlugBug", 100, 10);c1.RegisterWithCarEngine(new Car.CarEngineHandler(OnCarEngineEvent));Car.CarEngineHandler handler2 = new Car.CarEngineHandler(OnCarEngineEvent2);c1.RegisterWithCarEngine(handler2);...Конечно, если необходимо вызывать любые унаследованные члены класса
MulticastDelegateDelegateДля простоты в языке C# предлагается сокращение, называемое групповым преобразованием методов. Это средство позволяет указывать вместо объекта делегата прямое имя метода, когда вызываются методы, которые принимают делегаты в качестве аргументов.
На заметку! Позже в главе вы увидите, что синтаксис группового преобразования методов можно также использовать для упрощения регистрации событий С#.
В целях иллюстрации внесите в файл
Program.cs...Console.WriteLine("***** Method Group Conversion *****\n");Car c2 = new Car();// Зарегистрировать простое имя метода.c2.RegisterWithCarEngine(OnCarEngineEvent);Console.WriteLine("***** Speeding up *****");for (int i = 0; i < 6; i++){ c2.Accelerate(20);}// Отменить регистрацию простого имени метода.c2.UnRegisterWithCarEngine(OnCarEngineEvent);// Уведомления больше не поступают!for (int i = 0; i < 6; i++){ c2.Accelerate(20);}Console.ReadLine();Обратите внимание, что мы не создаем напрямую ассоциированный объект делегата, а просто указываем метод, который соответствует ожидаемой сигнатуре делегата (в данном случае метод, возвращающий
voidstringOnCarEngineEvent()stringvoidПонятие обобщенных делегатов
В главе 10 упоминалось о том, что язык C# позволяет определять обобщенные типы делегатов. Например, предположим, что необходимо определить тип делегата, который может вызывать любой метод, возвращающий
voidGenericDelegateConsole.WriteLine("***** Generic Delegates *****\n");// Зарегистрировать цели.MyGenericDelegate strTarget = new MyGenericDelegate(StringTarget); strTarget("Some string data");// Использовать синтаксис группового преобразования методовMyGenericDelegate intTarget = IntTarget; intTarget(9);Console.ReadLine();static void StringTarget(string arg){ Console.WriteLine("arg in uppercase is: {0}", arg.ToUpper());}static void IntTarget(int arg){ Console.WriteLine("++arg is: {0}", ++arg);}// Этот обобщенный делегат может вызывать любой метод, который// возвращает void и принимает единственный параметр типа Т.public delegate void MyGenericDelegate(T arg); Как видите, в типе делегата
MyGenericDelegatestring// Создать экземпляр MyGenericDelegate// с указанием string в качестве параметра типа.
MyGenericDelegate strTarget = StringTarget; strTarget("Some string data");С учетом формата объекта
strTargetStringTargetstatic void StringTarget(string arg){ Console.WriteLine( "arg in uppercase is: {0}", arg.ToUpper());}Обобщенные делегаты Action<> и Func<>
В настоящей главе вы уже видели, что когда нужно применять делегаты для обратных вызовов в приложениях, обычно должны быть выполнены описанные далее шаги.
1. Определить специальный делегат, соответствующий формату метода, на который он указывает.
2. Создать экземпляр специального делегата, передав имя метода в качестве аргумента конструктора.
3. Косвенно обратиться к методу через вызов
Invoke()В случае принятия такого подхода в итоге, как правило, получается несколько специальных делегатов, которые могут никогда не использоваться за рамками текущей задачи (например,
MyGenericDelegateCarEngineHandlervoidAction<>Func<>ActionAndFuncDelegatesОбобщенный делегат
Action<>SystemvoidAction<>Модифицируйте класс
Program// Это цель для делегата Action<>.static void DisplayMessage(string msg, ConsoleColor txtColor, int printCount){ // Установить цвет текста консоли. ConsoleColor previous = Console.ForegroundColor; Console.ForegroundColor = txtColor; for (int i = 0; i < printCount; i++) { Console.WriteLine(msg); } // Восстановить цвет. Console.ForegroundColor = previous;}Теперь вместо построения специального делегата вручную для передачи потока программы методу
DisplayMessage()Action<>Console.WriteLine("***** Fun with Action and Func *****");// Использовать делегат Action<> для указания на метод DisplayMessage().Action actionTarget = DisplayMessage;actionTarget("Action Message!", ConsoleColor.Yellow, 5);Console.ReadLine();Как видите, при использовании делегата
Action<>Action<>voidFunc<>Обобщенный делегат
Funс<>Action<>Program// Цель для делегата Func<>.static int Add(int x, int y){ return x + y;}Ранее в главе был построен специальный делегат
BinaryOpFunc<>Func<>Programstatic string SumToString(int x, int y){ return (x + y).ToString();}Вызовите эти методы:
Func funcTarget = Add; int result = funcTarget.Invoke(40, 40);Console.WriteLine("40 + 40 = {0}", result);Func funcTarget2 = SumToString; string sum = funcTarget2(90, 300);Console.WriteLine(sum);С учетом того, что делегаты
Action<>Func<>Action<>Func<>На заметку! Делегаты
Action<>Func<>Итак, первоначальный экскурс в типы делегатов окончен. Теперь давайте перейдем к обсуждению связанной темы — ключевого слова
eventПонятие событий C#
Делегаты — довольно интересные конструкции в том плане, что позволяют объектам, находящимся в памяти, участвовать в двустороннем взаимодействии. Тем не менее, прямая работа с делегатами может приводить к написанию стереотипного кода (определение делегата, определение необходимых переменных-членов, создание специальных методов регистрации и отмены регистрации для предохранения инкапсуляции и т.д.).
Более того, во время применения делегатов непосредственным образом как механизма обратного вызова в приложениях, если вы не определите переменную-член типа делегата в классе как закрытую, тогда вызывающий код будет иметь прямой доступ к объектам делегатов. В таком случае вызывающий код может присвоить переменной-члену новый объект делегата (фактически удаляя текущий список функций, которые подлежат вызову) и, что даже хуже, вызывающий код сможет напрямую обращаться к списку вызовов делегата. В целях демонстрации создайте новый проект консольного приложения по имени
PublicDelegateProblemCarCarDelegatenamespace PublicDelegateproblem{ public class Car { public delegate void CarEngineHandler(string msgForCaller); // Теперь это член public! public CarEngineHandler ListOfHandlers; // Просто вызвать уведомление Exploded. public void Accelerate(int delta) { if (ListOfHandlers != null) { ListOfHandlers("Sorry, this car is dead..."); } } }}Обратите внимание, что у вас больше нет закрытых переменных-членов с типами делегатов, инкапсулированных с помощью специальных методов регистрации. Поскольку эти члены на самом деле открытые, вызывающий код может получить доступ прямо к переменной-члену
ListOfHandlersCarEngineHandlerusing System;using PublicDelegateProblem;Console.WriteLine("***** Agh! No Encapsulation! *****\n");// Создать объект Car.Car myCar = new Car();// Есть прямой доступ к делегату!myCar.ListOfHandlers = CallWhenExploded;myCar.Accelerate(10);// Теперь можно присвоить полностью новый объект...// что в лучшем случае сбивает с толку.myCar.ListOfHandlers = CallHereToo;myCar.Accelerate(10);// Вызывающий код может также напрямую вызывать делегат!myCar.ListOfHandlers.Invoke("hee, hee, hee...");Console.ReadLine();static void CallWhenExploded(string msg){ Console.WriteLine(msg);}static void CallHereToo(string msg){ Console.WriteLine(msg);}Открытие доступа к членам типа делегата нарушает инкапсуляцию, что не только затруднит сопровождение кода (и отладку), но также сделает приложение уязвимым в плане безопасности! Ниже показан вывод текущего примера:
***** Agh! No Encapsulation! *****Sorry, this car is dead...Sorry, this car is dead...hee, hee, hee...Очевидно, что вы не захотите предоставлять другим приложениям возможность изменять то, на что указывает делегат, или вызывать его члены без вашего разрешения. С учетом сказанного общепринятая практика предусматривает объявление переменных-членов, имеющих типы делегатов, как закрытых.
Ключевое слово event
В качестве сокращения, избавляющего от необходимости создавать специальные методы для добавления и удаления методов из списка вызовов делегата, в языке C# предлагается ключевое слово
eventeventОпределение события представляет собой двухэтапный процесс. Во-первых, понадобится определить тип делегата (или задействовать существующий тип), который будет хранить список методов, подлежащих вызову при возникновении события. Во-вторых, необходимо объявить событие (с применением ключевого слова
eventЧтобы продемонстрировать использование ключевого слова event, создайте новый проект консольного приложения по имени
CarEventsCarAboutToBlowExplodedCarEngineHandlerCarusing System;namespace CarEvents{ public class Car { ... // Этот делегат работает в сочетании с событиями Car. public delegate void CarEngineHandler(string msgForCaller); // Этот объект Car может отправлять следующие события: public event CarEngineHandler Exploded; public event CarEngineHandler AboutToBlow; ... }}Отправка события вызывающему коду сводится просто к указанию события по имени наряду со всеми обязательными параметрами, как определено ассоциированным делегатом. Чтобы удостовериться в том, что вызывающий код действительно зарегистрировал событие, перед вызовом набора методов делегата событие следует проверить на равенство
nullAccelerate()Carpublic void Accelerate(int delta){ // Если автомобиль сломан, то инициировать событие Exploded. if (_carIsDead) { Exploded?.Invoke("Sorry, this car is dead..."); } else { CurrentSpeed += delta; // Почти сломан? if (10 == MaxSpeed - CurrentSpeed) { AboutToBlow?.Invoke("Careful buddy! Gonna blow!"); } // Все еще в порядке! if (CurrentSpeed >= MaxSpeed) { _carIsDead = true; } else { Console.WriteLine("CurrentSpeed = {0}", CurrentSpeed); } }}Итак, класс
Car"За кулисами" событий
Когда компилятор C# обрабатывает ключевое слово event, он генерирует два скрытых метода, один с префиксом
add_remove_Explodedadd_Exploded()remove_Exploded()add_AboutToBlow()Delegate.Combine().method public hidebysig specialname instance void add_AboutToBlow( class [System.Runtime]System.EventHandler`1 CarEventArgs> 'value') cil managed { ... IL_000b: call class [System.Runtime]System.Delegate [System.Runtime]System. Delegate::Combine(class [System.Runtime]System.Delegate, class [System.Runtime]System.Delegate) ... } // end of method Car::add_AboutToBlowКак и можно было ожидать, метод
remove_AboutToBlow()Delegate.Remove()public hidebysig specialname instance void remove_AboutToBlow ( class [System.Runtime]System.EventHandler`1 'value') cil managed { ... IL_000b: call class [System.Runtime]System.Delegate [System.Runtime]System. Delegate::Remove(class [System.Runtime]System.Delegate, class [System.Runtime]System.Delegate) ...}Наконец, в коде CIL, представляющем само событие, используются директивы
.addon.removeonadd_XXX()remove_XXX().event class [System.Runtime]System.EventHandler`1 AboutToBlow { .addon instance void CarEvents.Car::add_AboutToBlow( class [System.Runtime]System.EventHandler`1 ) .removeon instance void CarEvents.Car::remove_AboutToBlow( class [System.Runtime]System.EventHandler`1 ) } // end of event Car::AboutToBlowТеперь, когда вы понимаете, каким образом строить класс, способный отправлять события C# (и знаете, что события — всего лишь способ сэкономить время на наборе кода), следующий крупный вопрос связан с организацией прослушивания входящих событий на стороне вызывающего кода.
Прослушивание входящих событий
События C# также упрощают действие по регистрации обработчиков событий на стороне вызывающего кода. Вместо того чтобы указывать специальные вспомогательные методы, вызывающий код просто применяет операции
+=-=add_XXX()remove_XXX()// ИмяОбъекта.ИмяСобытия +=// new СвязанныйДелегат(функцияДляВызова);Car.CarEngineHandler d = new Car.CarEngineHandler(CarExplodedEventHandler);myCar.Exploded += d;Отключить от источника событий можно с помощью операции
-=// ИмяОбъекта.ИмяСобытия - =// СвязанныйДелегат(функцияДляВызова);myCar.Exploded -= d;Кроме того, с событиями можно использовать синтаксис группового преобразования методов:
Car.CarEngineHandler d = CarExplodedEventHandler;myCar.Exploded += d;При наличии таких весьма предсказуемых шаблонов переделайте вызывающий код, применив на этот раз синтаксис регистрации событий С#:
Console.WriteLine("***** Fun with Events *****\n");Car c1 = new Car("SlugBug", 100, 10);// Зарегистрировать обработчики событий.c1.AboutToBlow += CarIsAlmostDoomed;c1.AboutToBlow += CarAboutToBlow;Car.CarEngineHandler d = CarExploded;c1.Exploded += d;Console.WriteLine("***** Speeding up *****");for (int i = 0; i < 6; i++){ c1.Accelerate(20);}// Удалить метод CarExploded() из списка вызовов.c1.Exploded -= d;Console.WriteLine("\n***** Speeding up *****");for (int i = 0; i < 6; i++){ c1.Accelerate(20);}Console.ReadLine();static void CarAboutToBlow(string msg){ Console.WriteLine(msg);}static void CarIsAlmostDoomed(string msg){ Console.WriteLine("=> Critical Message from Car: {0}", msg);}static void CarExploded(string msg){ Console.WriteLine(msg);}Упрощение регистрации событий с использованием Visual Studio
Среда Visual Studio предлагает помощь в процессе регистрации обработчиков событий. В случае применения синтаксиса
+=
После нажатия клавиши <ТаЬ> будет сгенерирован новый метод, как показано на рис. 12.2.
Обратите внимание, что код заглушки имеет корректный формат цели делегата (кроме того, метод объявлен как
staticstatic void NewCar_AboutToBlow(string msg){ throw new NotImplementedException();}Средство IntelliSense доступно для всех событий .NET Core, ваших событий и событий из библиотек базовых классов.Такая возможность IDE-среды значительно экономит время, избавляя от необходимости выяснять с помощью справочной системы подходящий тип делегата для применения с заданным событием и формат целевого метода делегата.
Создание специальных аргументов событий
По правде говоря, в текущую итерацию класса
CarSystem.ObjectSystem.EventArgsПараметр
System.ObjectCarSystem.EventArgspublic class EventArgs{ public static readonly EventArgs Empty; public EventArgs();}Для простых событий экземпляр
EventArgsEventArgsCarEventArgsusing System;namespace CarEvents{ public class CarEventArgs : EventArgs { public readonly string msg; public CarEventArgs(string message) { msg = message; } }}Теперь можно модифицировать тип делегата
CarEngineHandlerpublic class Car{ public delegate void CarEngineHandler(object sender, CarEventArgs e); ...}Здесь при инициировании событий внутри метода
Accelerate()CarthisCarEventArgspublic void Accelerate(int delta){ // Если этот автомобиль сломан, то инициировать событие Exploded. if (carIsDead) { Exploded?.Invoke(this, new CarEventArgs("Sorry, this car is dead...")); } ...}На вызывающей стороне понадобится лишь модифицировать обработчики событий для приема входных параметров и получения сообщения через поле, доступное только для чтения. Вот пример:
static void CarAboutToBlow(object sender, CarEventArgs e){ Console.WriteLine($"{sender} says: {e.msg}");}Если получатель желает взаимодействовать с объектом, отправившим событие, тогда можно выполнить явное приведение
System.Objectstatic void CarAboutToBlow(object sender, CarEventArgs e){ // Просто для подстраховки перед приведением // произвести проверку во время выполнения. if (sender is Car c) { Console.WriteLine( $"Critical Message from {c.PetName}: {e.msg}"); }}
Обобщенный делегат EventHandler
С учетом того, что очень многие специальные делегаты принимают экземпляр
objectEventArgsEventHandlerТEventArgsCarpublic class Car{... public event EventHandler Exploded; public event EventHandler AboutToBlow; }Затем в вызывающем коде тип
EventHandlerCarEngineHandlerConsole.WriteLine("***** Prim and Proper Events *****\n");// Создать объект Car обычным образом.Car c1 = new Car("SlugBug", 100, 10);// Зарегистрировать обработчики событий.c1.AboutToBlow += CarIsAlmostDoomed;c1.AboutToBlow += CarAboutToBlow;EventHandler d = CarExploded; c1.Exploded += d;...Итак, к настоящему моменту вы узнали основные аспекты работы с делегатами и событиями в С#. Хотя этого вполне достаточно для решения практически любых задач, связанных с обратными вызовами, в завершение главы мы рассмотрим несколько финальных упрощений, в частности анонимные методы и лямбда-выражения.
Понятие анонимных методов C#
Как было показано ранее, когда вызывающий код желает прослушивать входящие события, он должен определить специальный метод в классе (или структуре), который соответствует сигнатуре ассоциированного делегата. Ниже приведен пример:
SomeType t = new SomeType();// Предположим, что SomeDeletage может указывать на методы,// которые не принимают аргументов и возвращают void.t.SomeEvent += new SomeDelegate(MyEventHandler);// Обычно вызывается только объектом SomeDelegate.static void MyEventHandler(){ // Делать что-нибудь при возникновении события.}Однако если подумать, то такие методы, как
MyEventHandler()Для решения указанной проблемы событие можно ассоциировать прямо с блоком операторов кода во время регистрации события. Формально такой код называется анонимным методом. Чтобы ознакомиться с синтаксисом, создайте новый проект консольного приложения по имени
AnonymousMethodsCar.csCarEventArgs.csCarEventsAnonymousMethodsProgram.csCarusing System;using AnonymousMethods;Console.WriteLine("***** Anonymous Methods *****\n");Car c1 = new Car("SlugBug", 100, 10);// Зарегистрировать обработчики событий как анонимные методы.c1.AboutToBlow += delegate{ Console.WriteLine("Eek! Going too fast!");};c1.AboutToBlow += delegate(object sender, CarEventArgs e){ Console.WriteLine("Message from Car: {0}", e.msg);};c1.Exploded += delegate(object sender, CarEventArgs e){ Console.WriteLine("Fatal Message from Car: {0}", e.msg);};// В конце концов, этот код будет инициировать события.for (int i = 0; i < 6; i++){ c1.Accelerate(20);}Console.ReadLine();На заметку! После финальной фигурной скобки в анонимном методе должна быть помещена точка с запятой, иначе возникнет ошибка на этапе компиляции.
И снова легко заметить, что специальные статические обработчики событий вроде
CarAboutToBlow()CarExploded()+=НекоторыйТип t = new НекоторыйТип();
t.НекотороеСобытие += delegate (необязательноУказываемыеАргументыДелегата)
{ /* операторы */ };
Обратите внимание, что при обработке первого события
AboutToBlowc1.AboutToBlow += delegate{ Console.WriteLine("Eek! Going too fast!");};Строго говоря, вы не обязаны принимать входные аргументы, отправленные специфическим событием. Но если вы хотите задействовать эти входные аргументы, тогда понадобится указать параметры, прототипированные типом делегата (как показано во второй обработке событий
AboutToBlowExplodedc1.AboutToBlow += delegate(object sender, CarEventArgs e){ Console.WriteLine("Critical Message from Car: {0}", e.msg);};Доступ к локальным переменным
Анонимные методы интересны тем, что способны обращаться к локальным переменным метода, где они определены. Формально такие переменные называются внешними переменными анонимного метода. Ниже перечислены важные моменты, касающиеся взаимодействия между областью действия анонимного метода и областью действия метода, в котором он определен.
• Анонимный метод не имеет доступа к параметрам
refout• Анонимный метод не может иметь локальную переменную, имя которой совпадает с именем локальной переменной внешнего метода.
• Анонимный метод может обращаться к переменным экземпляра (или статическим переменным) из области действия внешнего класса.
• Анонимный метод может объявлять локальную переменную с тем же именем, что и у переменной-члена внешнего класса (локальные переменные имеют отдельную область действия и скрывают переменные-члены из внешнего класса).
Предположим, что в операторах верхнего уровня определена локальная переменная по имени
aboutToBlowCounterintAboutToBlowaboutToBlowCounterConsole.WriteLine("***** Anonymous Methods *****\n");int aboutToBlowCounter = 0;// Создать объект Car обычным образом.Car c1 = new Car("SlugBug", 100, 10);// Зарегистрировать обработчики событий как анонимные методы.c1.AboutToBlow += delegate{ aboutToBlowCounter++; Console.WriteLine("Eek! Going too fast!");};c1.AboutToBlow += delegate(object sender, CarEventArgs e){ aboutToBlowCounter++; Console.WriteLine("Critical Message from Car: {0}", e.msg);};...// В конце концов, это будет инициировать события.for (int i = 0; i < 6; i++){ c1.Accelerate(20);}Console.WriteLine("AboutToBlow event was fired {0} times.", aboutToBlowCounter);Console.ReadLine();После запуска модифицированного кода вы обнаружите, что финальный вывод
Console.WriteLine()AboutToBlowИспользование ключевого слова static с анонимными методами (нововведение в версии 9.0)
В предыдущем примере демонстрировались анонимные методы, которые взаимодействовали с переменными, объявленными вне области действия самих методов. Хотя возможно именно это входило в ваши намерения, прием нарушает инкапсуляцию и может привести к нежелательным побочным эффектам в программе. Вспомните из главы 4, что локальные функции могут быть изолированы от содержащего их кода за счет их настройки как статических, например:
static int AddWrapperWithStatic(int x, int y){ // Выполнить проверку достоверности return Add(x,y); static int Add(int x, int y) { return x + y; }}В версии C# 9.0 анонимные методы также могут быть помечены как статические с целью предохранения инкапсуляции и гарантирования того, что они не привнесут какие-либо побочные эффекты в код, где они содержатся. Вот как выглядит модифицированный анонимный метод:
c1.AboutToBlow += static delegate{ // Этот код приводит к ошибке на этапе компиляции, // потому что анонимный метод помечен как статический aboutToBlowCounter++; Console.WriteLine("Eek! Going too fast!");};Предыдущий код не скомпилируется из-за попытки анонимного метода получить доступ к переменной, объявленной вне области его действия.
Использование отбрасывания с анонимными методами (нововведение в версии 9.0)
Отбрасывание, представленное в главе 3, в версии C# 9.0 было обновлено с целью применения в качестве входных параметров, но с одной уловкой. Поскольку символ подчеркивания (
_Например, в следующем коде создается делегат
Func<>42Console.WriteLine("******** Discards with Anonymous Methods ********");Func constant = delegate (int _, int _) {return 42;}; Console.WriteLine("constant(3,4)={0}",constant(3,4));Понятие лямбда-выражений
Чтобы завершить знакомство с архитектурой событий .NET Core, необходимо исследовать лямбда-выражения. Как объяснялось ранее в главе, язык C# поддерживает возможность обработки событий "встраиваемым образом", позволяя назначать блок операторов кода прямо событию с применением анонимных методов вместо построения отдельного метода, который должен вызываться делегатом. Лямбда-выражения всего лишь лаконичный способ записи анонимных методов, который в конечном итоге упрощает работу с типами делегатов .NET Core.
В целях подготовки фундамента для изучения лямбда-выражений создайте новый проект консольного приложения по имени
LambdaExpressionsFindAll()List// Метод класса System.Collections.Generic.List. public List FindAll(Predicate match) Как видите, метод
FindAll()ListFindAll()System.Predicatebool// Этот делегат используется методом FindAll()// для извлечения подмножества.public delegate bool Predicate(T obj); Когда вызывается
FindAll()ListPredicatetruefalsetrueListПрежде чем мы посмотрим, как лямбда-выражения могут упростить работу с методом
FindAll()ProgramTraditionalDelegateSyntax()System.PredicateListusing System;using System.Collections.Generic;using LambdaExpressions;Console.WriteLine("***** Fun with Lambdas *****\n");TraditionalDelegateSyntax();Console.ReadLine();static void TraditionalDelegateSyntax(){ // Создать список целочисленных значений. List list = new List(); list.AddRange(new int[] { 20, 1, 4, 8, 9, 44 }); // Вызвать FindAll() с применением традиционного синтаксиса делегатов. Predicate callback = IsEvenNumber; List evenNumbers = list.FindAll(callback); Console.WriteLine("Here are your even numbers:"); foreach (int evenNumber in evenNumbers) { Console.Write("{0}\t", evenNumber); } Console.WriteLine();}// Цель для делегата Predicate<>.static bool IsEvenNumber(int i){ // Это четное число? return (i % 2) == 0;}Здесь имеется метод (
IsEvenNumber()%Наряду с тем, что такой традиционный подход к работе с делегатами ведет себя ожидаемым образом,
IsEvenNumber()FindAll()Programstatic void AnonymousMethodSyntax(){ // Создать список целочисленных значений. List list = new List(); list.AddRange(new int[] { 20, 1, 4, 8, 9, 44 }); // Теперь использовать анонимный метод. List evenNumbers = list.FindAll(delegate(int i) { return (i % 2) == 0; } ); // Вывести четные числа Console.WriteLine("Here are your even numbers:"); foreach (int evenNumber in evenNumbers) { Console.Write("{0}\t", evenNumber); } Console.WriteLine();}В данном случае вместо прямого создания объекта делегата
PredicatedelegatePredicateList evenNumbers = list.FindAll( delegate(int i) { return (i % 2) == 0; });Для еще большего упрощения вызова метода
FindAll()Programstatic void LambdaExpressionSyntax(){ // Создать список целочисленных значений. List list = new List(); list.AddRange(new int[] { 20, 1, 4, 8, 9, 44 }); // Теперь использовать лямбда-выражение С #. List evenNumbers = list.FindAll(i => (i % 2) == 0); // Вывести четные числа. Console.WriteLine("Here are your even numbers:"); foreach (int evenNumber in evenNumbers) { Console.Write("{0}\t", evenNumber); } Console.WriteLine();}Обратите внимание на довольно странный оператор кода, передаваемый методу
FindAll()Predicatedelegatei => (i % 2) == 0Перед разбором синтаксиса запомните, что лямбда-выражения могут использоваться везде, где должен применяться анонимный метод или строго типизированный делегат (обычно с клавиатурным набором гораздо меньшего объема). "За кулисами" компилятор C# транслирует лямбда-выражение в стандартный анонимный метод, использующий тип делегата
Predicateildasm.exe// Это лямбда-выражение... List evenNumbers = list.FindAll(i => (i % 2) == 0); компилируется в приблизительно такой код С#:
// ...становится следующим анонимным методом. List evenNumbers = list.FindAll(delegate (int i) { return (i % 2) == 0; }); Анализ лямбда-выражения
Лямбда-выражение начинается со списка параметров, за которым следует лексема
=>АргументыДляОбработки => ОбрабатывающиеОператоры
То, что находится внутри метода
LambdaExpressionSyntax()// i — список параметров.// (i % 2) == 0 - набор операторов для обработки iList evenNumbers = list.FindAll(i => (i % 2) == 0); Параметры лямбда-выражения могут быть явно или неявно типизированными. В настоящий момент тип данных, представляющий параметр
ii// Теперь установим тип параметров явно.List evenNumbers = list.FindAll((int i) => (i % 2) == 0); Как вы уже видели, если лямбда-выражение имеет одиночный неявно типизированный параметр, то круглые скобки в списке параметров могут быть опущены. Если вы желаете соблюдать согласованность относительно применения параметров лямбда-выражений, тогда можете всегда заключать в скобки список параметров:
List evenNumbers = list.FindAll((i) => (i % 2) == 0); Наконец, обратите внимание, что в текущий момент выражение не заключено в круглые скобки (естественно, вычисление остатка от деления помещено в скобки, чтобы гарантировать его выполнение перед проверкой на равенство). В лямбда-выражениях разрешено заключать оператор в круглые скобки:
// Поместить в скобки и выражение.List evenNumbers = list.FindAll((i) => ((i % 2) == 0)); После ознакомления с разными способами построения лямбда-выражения давайте выясним, как его можно читать в понятных человеку терминах. Оставив чистую математику в стороне, можно привести следующее объяснение:
// Список параметров (в данном случае единственное целочисленное// значение по имени i) будет обработан выражением (i % 2) == 0.List evenNumbers = list.FindAll((i) => ((i % 2) == 0)); Обработка аргументов внутри множества операторов
Первое рассмотренное лямбда-выражение включало единственный оператор, который в итоге вычислялся в булевское значение. Однако, как вы знаете, многие цели делегатов должны выполнять несколько операторов кода. По этой причине язык C# позволяет строить лямбда-выражения, состоящие из множества операторов, указывая блок кода в стандартных фигурных скобках. Взгляните на приведенную далее модификацию метода
LambdaExpressionSyntax()static void LambdaExpressionSyntax(){ // Создать список целочисленных значений. List list = new List(); list.AddRange(new int[] { 20, 1, 4, 8, 9, 44 }); // Обработать каждый аргумент внутри группы операторов кода. List evenNumbers = list.FindAll((i) => { // текущее значение i Console.WriteLine("value of i is currently: {0}", i); bool isEven = ((i % 2) == 0); return isEven; }); // Вывести четные числа Console.WriteLine("Here are your even numbers:"); foreach (int evenNumber in evenNumbers) { Console.Write("{0}\t", evenNumber); } Console.WriteLine();}В данном случае список параметров (опять состоящий из единственного целочисленного значения
iConsole.WriteLine()Console.WriteLine("***** Fun with Lambdas *****\n");TraditionalDelegateSyntax();AnonymousMethodSyntax();Console.WriteLine();LambdaExpressionSyntax();Console.ReadLine();Запуск приложения дает следующий вывод:
***** Fun with Lambdas *****Here are your even numbers:20 4 8 44Here are your even numbers:20 4 8 44value of i is currently: 20value of i is currently: 1value of i is currently: 4value of i is currently: 8value of i is currently: 9value of i is currently: 44Here are your even numbers:20 4 8 44 Лямбда-выражения с несколькими параметрами и без параметров
Показанные ранее лямбда-выражения обрабатывали единственный параметр. Тем не менее, это вовсе не обязательно, т.к. лямбда-выражения могут обрабатывать множество аргументов (или ни одного). Для демонстрации первого сценария с множеством аргументов добавьте показанную ниже версию класса
SimpleMathpublic class SimpleMath{ public delegate void MathMessage(string msg, int result); private MathMessage _mmDelegate; public void SetMathHandler(MathMessage target) { _mmDelegate = target; } public void Add(int x, int y) { _mmDelegate?.Invoke("Adding has completed!", x + y); }}Обратите внимание, что делегат
MathMessage// Зарегистрировать делегат как лямбда-выражение.SimpleMath m = new SimpleMath();m.SetMathHandler((msg, result) => {Console.WriteLine("Message: {0}, Result: {1}", msg, result);});// Это приведет к выполнению лямбда-выражения.m.Add(10, 10);Console.ReadLine();Здесь задействовано выведение типа, поскольку для простоты два параметра не были строго типизированы. Однако метод
SetMathHandler()m.SetMathHandler((string msg, int result) => {Console.WriteLine("Message: {0}, Result: {1}", msg, result);});Наконец, если лямбда-выражение применяется для взаимодействия с делегатом, который вообще не принимает параметров, то можно указать в качестве параметра пару пустых круглых скобок. Таким образом, предполагая, что определен приведенный далее тип делегата:
public delegate string VerySimpleDelegate();вот как можно было бы обработать результат вызова:
// Выводит на консоль строку "Enjoy your string!".VerySimpleDelegate d = new VerySimpleDelegate( () => {return "Enjoy your string!";} );Console.WriteLine(d());Используя новый синтаксис выражений, предыдущую строку можно записать следующим образом:
VerySimpleDelegate d2 = new VerySimpleDelegate(() => "Enjoy your string!");и даже сократить ее до такого вида:
VerySimpleDelegate d3 = () => "Enjoy your string!"; Использование ключевого слова static с лямбда-выражениями (нововведение в версии 9.0)
Поскольку лямбда-выражения являются сокращенной формой записи для делегатов, должно быть понятно, что они тоже поддерживают ключевое слово
staticvar outerVariable = 0;Func DoWork = (x,y) => { outerVariable++; return true;};DoWork(3,4);Console.WriteLine("Outer variable now = {0}", outerVariable);В результате выполнения этого кода получается следующий вывод:
***** Fun with Lambdas *****Outer variable now = 1Если вы сделаете лямбда-выражение статическим, тогда на этапе компиляции возникнет ошибка, т.к. выражение пытается модифицировать переменную, объявленную во внешней области действия:
var outerVariable = 0;Func DoWork = static (x,y) => { // Ошибка на этапе компиляции по причине доступа // к внешней переменной. // outerVariable++; return true;};Использование отбрасывания с лямбда-выражениями (нововведение в версии 9.0)
Как и в случае делегатов (начиная с версии C# 9.0), входные переменные лямбда-выражения можно заменять отбрасыванием, когда они не нужны. Здесь применяется та же самая уловка, что и в делегатах. Поскольку символ подчеркивания (
_var outerVariable = 0;Func DoWork = (x,y) => { outerVariable++; return true;};DoWork(_,_);Console.WriteLine("Outer variable now = {0}", outerVariable);Модернизация примера CarEvents с использованием лямбда-выражений
С учетом того, что основной целью лямбда-выражений является предоставление способа ясного и компактного определения анонимных методов (косвенно упрощая работу с делегатами), давайте модернизируем проект
CarEventsProgramCarusing System;using CarEventsWithLambdas;Console.WriteLine("***** More Fun with Lambdas *****\n");// Создать объект Car обычным образом.Car c1 = new Car("SlugBug", 100, 10);// Привязаться к событиям с помощью лямбда-выражений.c1.AboutToBlow += (sender, e) => { Console.WriteLine(e.msg);};c1.Exploded += (sender, e) => { Console.WriteLine(e.msg); };// Увеличить скорость (это инициирует события).Console.WriteLine("\n***** Speeding up *****");for (int i = 0; i < 6; i++){ c1.Accelerate(20);}Console.ReadLine();Лямбда-выражения и члены, сжатые до выражений (обновление в версии 7.0)
Понимая лямбда-выражения и зная, как они работают, вам должно стать намного яснее, каким образом внутренне функционируют члены, сжатые до выражений. В главе 4 упоминалось, что в версии C# 6 появилась возможность использовать операцию
=>getsetТем не менее, имейте в виду, что новый сокращенный синтаксис может применяться где угодно, даже когда код не имеет никакого отношения к делегатам или событиям. Таким образом, например, если вы строите элементарный класс для сложения двух чисел, то могли бы написать следующий код:
class SimpleMath{ public int Add(int x, int y) { return x + y; } public void PrintSum(int x, int y) { Console.WriteLine(x + y); }}В качестве альтернативы теперь код может выглядеть так:
class SimpleMath{ public int Add(int x, int y) => x + y; public void PrintSum(int x, int y) => Console.WriteLine(x + y);}В идеале к этому моменту вы должны уловить суть лямбда-выражений и понимать, что они предлагают "функциональный способ" работы с анонимными методами и типами делегатов. Хотя на привыкание к лямбда-операции (
=>АргументыДляОбработки =>{ ОбрабатывающиеОператоры}Или, если операция
=>ЧленТипа => ЕдинственныйОператорКодаПолезно отметить, что лямбда-выражения широко задействованы также в модели программирования LINQ, помогая упростить кодирование. Исследование LINQ начинается в главе 13.
Резюме
В настоящей главе вы получили представление о нескольких способах организации двустороннего взаимодействия для множества объектов. Во-первых, было рассмотрено ключевое слово
delegateSystem.MulticastDelegateВо-вторых, вы ознакомились с ключевым словом event, которое в сочетании с типом делегата может упростить процесс отправки уведомлений ожидающим объектам. Как можно заметить в результирующем коде CIL, модель событий .NET отображается на скрытые обращения к типам
System.Delegate/System.MulticastDelegateВ данном отношении ключевое слово event является совершенно необязательным, т.к. оно просто позволяет сэкономить на наборе кода. Кроме того, вы видели, что
nullВ-третьих, в главе также рассматривалось средство языка С#, которое называется анонимными методами. С помощью такой синтаксической конструкции можно явно ассоциировать блок операторов кода с заданным событием. Было показано, что анонимные методы вполне могут игнорировать параметры, переданные событием, и имеют доступ к "внешним переменным" определяющего их метода. Вы также освоили упрощенный подход к регистрации событий с применением групповых преобразований методов.
Наконец, в-четвертых, вы взглянули на лямбда-операцию (
=>Глава 13 LINQ to Objects
Независимо от типа приложения, которое вы создаете с использованием платформы .NET Core, во время выполнения ваша программа непременно будет нуждаться в доступе к данным какой-нибудь формы. Разумеется, данные могут находиться в многочисленных местах, включая файлы XML, реляционные базы данных, коллекции в памяти и элементарные массивы. Исторически сложилось так, что в зависимости от места хранения данных программистам приходилось применять разные и несвязанные друг с другом API-интерфейсы. Набор технологий LINQ (Language Integrated Query — язык интегрированных запросов), появившийся в версии .NET 3.5, предоставил краткий, симметричный и строго типизированный способ доступа к широкому разнообразию хранилищ данных. В настоящей главе изучение LINQ начинается с исследования LINQ to Objects.
Прежде чем погрузиться в LINQ to Objects, в первой части главы предлагается обзор основных программных конструкций языка С#, которые делают возможным существование LINQ. По мере чтения главы вы убедитесь, насколько полезны (а иногда и обязательны) такие средства, как неявно типизированные переменные, синтаксис инициализации объектов, лямбда-выражения, расширяющие методы и анонимные типы.
После пересмотра поддерживающей инфраструктуры в оставшемся материале главы будет представлена модель программирования LINQ и объяснена ее роль в рамках платформы .NET. Вы узнаете, для чего предназначены операции и выражения запросов, позволяющие определять операторы, которые будут опрашивать источник данных с целью выдачи требуемого результирующего набора. Попутно будут строиться многочисленные примеры LINQ, взаимодействующие с данными в массивах и коллекциях различного типа (обобщенных и необобщенных), а также исследоваться сборки, пространства имен и типы, которые представляют API-интерфейс LINQ to Objects.
На заметку! Информация, приведенная в главе, послужит фундаментом для освоения материала последующих глав книги, включая Parallel LINQ (глава 15) и Entity Framework Core (главы 22 и 23) .
Программные конструкции, специфичные для LINQ
С высокоуровневой точки зрения LINQ можно трактовать как строго типизированный язык запросов, встроенный непосредственно в грамматику самого языка С#. Используя LINQ, можно создавать любое количество выражений, которые выглядят и ведут себя подобно SQL-запросам к базе данных. Однако запрос LINQ может применяться к любым хранилищам данных, включая хранилища, которые не имеют ничего общего с подлинными реляционными базами данных.
На заметку! Хотя запросы LINQ внешне похожи на запросы SQL, их синтаксис не идентичен. В действительности многие запросы LINQ имеют формат, прямо противоположный формату подобного запроса к базе данных! Если вы попытаетесь отобразить LINQ непосредственно на SQL, то определенно запутаетесь. Чтобы подобного не произошло, рекомендуется воспринимать запросы LINQ как уникальные операторы, которые просто случайно оказались похожими на SQL.
Когда LINQ впервые был представлен в составе платформы .NET 3.5, языки C# и VB уже были расширены множеством новых программных конструкций для поддержки набора технологий LINQ. В частности, язык C# использует следующие связанные с LINQ средства:
• неявно типизированные локальные переменные:
• синтаксис инициализации объектов и коллекций;
• лямбда-выражения;
• расширяющие методы ;
• анонимные типы.
Перечисленные средства уже детально рассматривались в других главах книги. Тем не менее, чтобы освежить все в памяти, давайте быстро вспомним о каждом средстве по очереди, удостоверившись в правильном их понимании.
На заметку! Из-за того, что в последующих разделах приводится обзор материала, рассматриваемого где-то в других местах книги, проект кода C# здесь не предусмотрен.
Неявная типизация локальных переменных
В главе 3 вы узнали о ключевом слове
varstatic void DeclareImplicitVars(){ // Неявно типизированные локальные переменные. var myInt = 0; var myBool = true; var myString = "Time, marches on..."; // Вывести имена лежащих в основе типов. Console.WriteLine("myInt is a: {0}", myInt.GetType().Name); Console.WriteLine("myBool is a: {0}", myBool.GetType().Name); Console.WriteLine("myString is a: {0}", myString.GetType().Name);}Это языковое средство удобно и зачастую обязательно, когда применяется LINQ. Как вы увидите на протяжении главы, многие запросы LINQ возвращают последовательность типов данных, которые не будут известны вплоть до этапа компиляции. Учитывая, что лежащий в основе тип данных не известен до того, как приложение скомпилируется, вполне очевидно, что явно объявить такую переменную невозможно!
Синтаксис инициализации объектов и коллекций
В главе 5 объяснялась роль синтаксиса инициализации объектов, который позволяет создавать переменную типа класса или структуры и устанавливать любое количество ее открытых свойств за один прием. В результате получается компактный (и по-прежнему легко читаемый) синтаксис, который может использоваться для подготовки объектов к потреблению. Также вспомните из главы 10, что язык C# поддерживает похожий синтаксис инициализации коллекций объектов. Взгляните на следующий фрагмент кода, где синтаксис инициализации коллекций применяется для наполнения
ListRectanglePointList myListOfRects = new List { new Rectangle {TopLeft = new Point { X = 10, Y = 10 }, BottomRight = new Point { X = 200, Y = 200}}, new Rectangle {TopLeft = new Point { X = 2, Y = 2 }, BottomRight = new Point { X = 100, Y = 100}}, new Rectangle {TopLeft = new Point { X = 5, Y = 5 }, BottomRight = new Point { X = 90, Y = 75}}};Несмотря на то что использовать синтаксис инициализации коллекций или объектов совершенно не обязательно, с его помощью можно получить более компактную кодовую базу. Кроме того, этот синтаксис в сочетании с неявной типизацией локальных переменных позволяет объявлять анонимный тип, что удобно при создании проекций LINQ. О проекциях LINQ речь пойдет позже в главе.
Лямбда-выражения
Лямбда-операция C# (
=>АргументыДляОбработки =>{ ОбрабатывающиеОператоры}В главе 12 было показано, как взаимодействовать с методом
FindAll()ListPredicatestatic void LambdaExpressionSyntax(){ // Создать список целочисленных значений. List list = new List(); list.AddRange(new int[] { 20, 1, 4, 8, 9, 44 }); // Теперь использовать лямбда-выражение С#. List evenNumbers = list.FindAll(i => (i % 2) == 0); // Вывести четные числа Console.WriteLine("Here are your even numbers:"); foreach (int evenNumber in evenNumbers) { Console.Write("{0}\t", evenNumber); } Console.WriteLine();}Лямбда-выражения будут удобны при работе с объектной моделью, лежащей в основе LINQ. Как вы вскоре выясните, операции запросов LINQ в C# — просто сокращенная запись для вызова методов класса по имени
System.Linq.EnumerableFunс<>Расширяющие методы
Расширяющие методы C# позволяют оснащать существующие классы новой функциональностью без необходимости в создании подклассов. Кроме того, расширяющие методы дают возможность добавлять новую функциональность к запечатанным классам и структурам, которые в принципе не допускают построения подклассов. Вспомните из главы 11, что когда создается расширяющий метод, первый его параметр снабжается ключевым словом
thisstaticnamespace MyExtensions{ static class ObjectExtensions { // Определить расширяющий метод для System.Object. public static void DisplayDefiningAssembly( this object obj) { Console.WriteLine("{0} lives here:\n\t->{1}\n", obj.GetType().Name, Assembly.GetAssembly(obj.GetType())); } }}Чтобы использовать такое расширение, приложение должно импортировать пространство имен, определяющее расширение (и возможно добавить ссылку на внешнюю сборку). Затем можно приступать к написанию кода:
// Поскольку все типы расширяют System.Object, все// классы и структуры могут использовать это расширение.int myInt = 12345678;myInt.DisplayDefiningAssembly();System.Data.DataSet d = new System.Data.DataSet();d.DisplayDefiningAssembly();При работе c LINQ вам редко (если вообще когда-либо) потребуется вручную строить собственные расширяющие методы. Тем не менее, создавая выражения запросов LINQ, вы на самом деле будете применять многочисленные расширяющие методы, уже определенные разработчиками из Microsoft. Фактически каждая операция запроса LINQ в C# представляет собой сокращенную запись для ручного вызова лежащего в основе расширяющего метода, который обычно определен в служебном классе
System.Linq.EnumerableАнонимные типы
Последним средством языка С#, описание которого здесь кратко повторяется, являются анонимные типы, рассмотренные в главе 11. Данное средство может использоваться для быстрого моделирования "формы" данных, разрешая компилятору генерировать на этапе компиляции новое определение класса, которое основано на предоставленном наборе пар "имя-значение". Вспомните, что результирующий тип составляется с применением семантики на основе значений, а каждый виртуальный метод
System.Object// Создать анонимный тип, состоящий из еще одного анонимного типа.var purchaseItem = new { TimeBought = DateTime.Now, ItemBought = new {Color = "Red", Make = "Saab", CurrentSpeed = 55}, Price = 34.000};Анонимные типы часто применяются в LINQ, когда необходимо проецировать в новые формы данных на лету. Например, предположим, что есть коллекция объектов
PersonРоль LINQ
На этом краткий обзор средств языка С#, которые позволяют LINQ делать свою работу, завершен. Однако важно понимать, зачем вообще нужен язык LINQ. Любой разработчик программного обеспечения согласится с утверждением, что значительное время при программировании тратится на получение и манипулирование данными. Когда говорят о "данных", на ум немедленно приходит информация, хранящаяся внутри реляционных баз данных. Тем не менее, другими популярными местоположениями для данных являются документы XML или простые текстовые файлы.
Данные могут находиться в многочисленных местах помимо указанных двух распространенных хранилищ информации. Например, пусть имеется массив или обобщенный тип
ListДо появления версии .NET 3.5 взаимодействие с отдельной разновидностью данных требовало от программистов применения совершенно несходных API-интерфейсов. В табл. 13.1 описаны некоторые популярные API-интерфейсы, используемые для доступа к разнообразным типам данных (наверняка вы в состоянии привести и другие примеры).
Разумеется, с такими подходами к манипулированию данными не связано ничего плохого. В сущности, вы можете (и будете) работать напрямую с ADO.NET, пространствами имен XML, службами рефлексии и разнообразными типами коллекций. Однако основная проблема заключается в том, что каждый из API-интерфейсов подобного рода является "самостоятельным островком", трудно интегрируемым с другими. Правда, можно (например) сохранить объект
DataSetSystem.xmlВ рамках API-интерфейса LINQ была предпринята попытка предложить программистам согласованный, симметричный способ получения и манипулирования "данными" в широком смысле этого понятия. Применяя LINQ, прямо внутри языка программирования C# можно создавать конструкции, которые называются выражениями запросов. Такие выражения запросов основаны на многочисленных операциях запросов, которые намеренно сделаны похожими внешне и по поведению (но не идентичными) на выражения SQL.
Тем не менее, трюк заключается в том, что выражение запроса может использоваться для взаимодействия с разнообразными типами данных — даже с теми, которые не имеют ничего общего с реляционными базами данных. Строго говоря, LINQ представляет собой термин, в целом описывающий сам подход доступа к данным. Однако в зависимости от того, где применяются запросы LINQ, вы встретите разные обозначения вроде перечисленных ниже.
• LINQ to Objects. Этот термин относится к действию по применению запросов LINQ к массивам и коллекциям.
• LINQ to XML. Этот термин относится к действию по использованию LINQ для манипулирования и запрашивания документов XML.
• LINQ to Entities. Этот аспект LINQ позволяет использовать запросы LINQ внутри API-интерфейса ADO.NET Entity Framework (EF) Core.
• Parallel LINQ (PLINQ). Этот аспект делает возможной параллельную обработку данных, возвращаемых из запроса LINQ.
В настоящее время LINQ является неотъемлемой частью библиотек базовых классов .NET Core, управляемых языков и самой среды Visual Studio.
Выражения LINQ строго типизированы
Важно также отметить, что выражение запроса LINQ (в отличие от традиционного оператора SQL) строго типизировано. Следовательно, компилятор C# следит за этим и гарантирует, что выражения оформлены корректно с точки зрения синтаксиса. Инструменты вроде Visual Studio могут применять метаданные для поддержки удобных средств, таких как IntelliSense, автозавершение и т.д.
Основные сборки LINQ
Для работы с LINQ to Objects вы должны обеспечить импортирование пространства имен
System.Linqusingusing System.Linq;Применение запросов LINQ к элементарным массивам
Чтобы начать исследование LINQ to Objects, давайте построим приложение, которое будет применять запросы LINQ к разнообразным объектам типа массива. Создайте новый проект консольного приложения под названием
LinqOverArrayProgramQueryOverStrings()stringstatic void QueryOverStrings(){ // Предположим, что есть массив строк. string[] currentVideoGames = {"Morrowind", "Uncharted 2", "Fallout 3", "Daxter", "System Shock 2"};}Теперь модифицируйте файл
Program.csQueryOver Strings()Console.WriteLine("***** Fun with LINQ to Objects *****\n");QueryOverStrings();Console.ReadLine();При работе с любым массивом данных часто приходится извлекать из него подмножество элементов на основе определенного критерия. Возможно, требуется получить только элементы, которые содержат число (например, "System Shock 2", "Uncharted 2" и "Fallout 3"), содержат заданное количество символов либо не содержат встроенных пробелов (скажем, "Morrowind" или "Daxter"). В то время как такие задачи определенно можно решать с использованием членов типа
System.ArrayИсходя из предположения, что из массива нужно получить только элементы, содержащие внутри себя пробел, и представить их в алфавитном порядке, можно построить следующее выражение запроса LINQ:
static void QueryOverStrings(){ // Предположим, что имеется массив строк. string[] currentVideoGames = {"Morrowind", "Uncharted 2", "Fallout 3", "Daxter", "System Shock 2"}; // Построить выражение запроса для нахождения // элементов массива, которые содержат пробелы. IEnumerable subset = from g in currentVideoGames where g.Contains(" ") orderby g select g; // Вывести результаты. foreach (string s in subset) { Console.WriteLine("Item: {0}", s); }}Обратите внимание, что в созданном здесь выражении запроса применяются операции
frominwhereorderbyselectcurrentVideoGamesКаждому элементу, который соответствует критерию поиска, назначается имя
gIEnumerable subset = from game in currentVideoGames where game.Contains(" ") orderby game select game;Возвращенная последовательность сохраняется в переменной по имени
subsetIEnumerableТSystem.Stringstringforeach***** Fun with LINQ to Objects *****Item: Fallout 3Item: System Shock 2Item: Uncharted 2Решение с использованием расширяющих методов
Применяемый ранее (и далее в главе) синтаксис LINQ называется выражениями запросов LINQ, которые представляют собой формат, похожий на SQL, но слегка отличающийся от него. Существует еще один синтаксис с расширяющими методами, который будет использоваться в большинстве примеров в настоящей книге. Создайте новый метод по имени
QueryOverStringsWithExtensionMethods()static void QueryOverStringsWithExtensionMethods(){ // Пусть имеется массив строк. string[] currentVideoGames = {"Morrowind", "Uncharted 2", "Fallout 3", "Daxter", "System Shock 2"}; // Построить выражение запроса для поиска // в массиве элементов, содержащих пробелы. IEnumerable subset = currentVideoGames.Where(g => g.Contains(" ")) .OrderBy(g => g).Select(g => g); // Вывести результаты. foreach (string s in subset) { Console.WriteLine("Item: {0}", s); }}Код здесь тот же, что и в предыдущем методе, кроме строк, выделенных полужирным. В них демонстрируется применение синтаксиса расширяющих методов, в котором для определения операций внутри каждого метода используются лямбда-выражения. Например, лямбда-выражение в методе
Where()vХотя результаты аналогичны (метод дает такой же вывод, как и предыдущий метод, использующий выражение запроса), вскоре вы увидите, что тип результирующего набора несколько отличается. В большинстве (если фактически не во всех) сценариях подобное отличие не приводит к каким-либо проблемам и форматы могут применяться взаимозаменяемо.
Решение без использования LINQ
Конечно, применение LINQ никогда не бывает обязательным. При желании идентичный результирующий набор можно получить без участия LINQ с помощью таких программных конструкций, как операторы
ifforQueryOverStrings()static void QueryOverStringsLongHand(){ // Предположим, что имеется массив строк. string[] currentVideoGames = {"Morrowind", "Uncharted 2", "Fallout 3", "Daxter", "System Shock 2"}; string[] gamesWithSpaces = new string[5]; for (int i = 0; i < currentVideoGames.Length; i++) { if (currentVideoGames[i].Contains(" ")) { gamesWithSpaces[i] = currentVideoGames[i]; } } // Отсортировать набор. Array.Sort(gamesWithSpaces); // Вывести результаты. foreach (string s in gamesWithSpaces) { if( s != null) { Console.WriteLine("Item: {0}", s); } } Console.WriteLine();}Несмотря на возможные пути улучшения метода
QueryOverStringsLongHand()if/elseВыполнение рефлексии результирующего набора LINQ
А теперь определите в классе
ProgramReflectOverQueryResults()System.Objectstatic void ReflectOverQueryResults(object resultSet, string queryType = "Query Expressions"){ Console.WriteLine($"***** Info about your query using {queryType} *****"); // Вывести тип результирующего набора Console.WriteLine("resultSet is of type: {0}", resultSet.GetType().Name); // Вывести местоположение результирующего набора Console.WriteLine("resultSet location: {0}", resultSet.GetType().Assembly.GetName().Name);}Модифицируйте код метода
QueryOverStrings()// Построить выражение запроса для поиска// в массиве элементов, содержащих пробел.IEnumerable subset = from g in currentVideoGames where g.Contains(" ") orderby g select g;ReflectOverQueryResults(subset);// Вывести результаты.foreach (string s in subset){ Console.WriteLine("Item: {0}", s);}Запустив приложение, легко заметить, что переменная
subsetOrderedEnumerableOrderedEnumerable`2System.Linq.dll***** Info about your query using Query Expressions*****resultSet is of type: OrderedEnumerable`2resultSet location: System.LinqВнесите такое же изменение в код метода
QueryOverStringsWithExtensionMethods()Extension Methods// Построить выражение запроса для поиска// в массиве элементов, содержащих пробел.IEnumerable subset = currentVideoGames .Where(g => g.Contains(" ")) .OrderBy(g => g).Select(g => g);ReflectOverQueryResults(subset,"Extension Methods");// Вывести результаты.foreach (string s in subset){ Console.WriteLine("Item: {0}", s);}После запуска приложения выяснится, что переменная
subsetSelectIPartitionIteratorSelect(g=>g)subsetOrderedEnumerableIEnumerable***** Info about your query using Extension Methods *****resultSet is of type: SelectIPartitionIterator`2resultSet location: System.LinqLINQ и неявно типизированные локальные переменные
Хотя в приведенной программе относительно легко выяснить, что результирующий набор может быть интерпретирован как перечисление объектов
stringIEnumerableOrderedEnumerableПоскольку результирующие наборы LINQ могут быть представлены с применением порядочного количества типов из разнообразных пространств имен LINQ, было бы утомительно определять подходящий тип для хранения результирующего набора. Причина в том, что во многих случаях лежащий в основе тип не очевиден и даже напрямую не доступен в коде (и как вы увидите, в ряде ситуаций тип генерируется на этапе компиляции).
Чтобы еще больше подчеркнуть данное обстоятельство, ниже показан дополнительный вспомогательный метод, определенный внутри класса
Programstatic void QueryOverInts(){ int[] numbers = {10, 20, 30, 40, 1, 2, 3, 8}; // Вывести только элементы меньше 10. IEnumerable subset = from i in numbers where i < 10 select i; foreach (int i in subset) { Console.WriteLine("Item: {0}", i); } ReflectOverQueryResults(subset);}В рассматриваемом случае переменная
subsetIEnumerableWhereArrayIteratorItem: 1Item: 2Item: 3Item: 8***** Info about your query *****resultSet is of type: WhereArrayIterator`1resultSet location: System.LinqУчитывая, что точный тип запроса LINQ не вполне очевиден, в первых примерах результаты запросов были представлены как переменная
IEnumerableТstringintIEnumerableIEnumerableSystem.Collections.IEnumerable subset = from i in numbers where i < 10 select i;К счастью, неявная типизация при работе с запросами LINQ значительно проясняет картину:
static void QueryOverInts(){ int[] numbers = {10, 20, 30, 40, 1, 2, 3, 8}; // Здесь используется неявная типизация... var subset = from i in numbers where i < 10 select i; // ...и здесь тоже. foreach (var i in subset) { Console.WriteLine("Item: {0} ", i); } ReflectOverQueryResults(subset);}В качестве эмпирического правила: при захвате результатов запроса LINQ всегда необходимо использовать неявную типизацию. Однако помните, что (в большинстве случаев) действительное возвращаемое значение имеет тип, реализующий интерфейс
IEnumerableКакой точно тип кроется за ним (
OrderedEnumerableWhereArrayIteratorforeachLINQ и расширяющие методы
Несмотря на то что в текущем примере совершенно не требуется напрямую писать какие-то расширяющие методы, на самом деле они благополучно используются на заднем плане. Выражения запросов LINQ могут применяться для прохода по содержимому контейнеров данных, которые реализуют обобщенный интерфейс
IEnumerableSystem.Array// Похоже, что тип System.Array не реализует// корректную инфраструктуру для выражений запросов!public abstract class Array : ICloneable, IList, IStructuralComparable, IStructuralEquatable{ ...}Хотя класс
System.ArrayIEnumerableSystem.Linq.EnumerableВ служебном классе
System.Linq.EnumerableAggregate() First() Мах<Т>()System.ArraycurrentVideoGamesSystem.ArrayРоль отложенного выполнения
Еще один важный момент, касающийся выражений запросов LINQ, заключается в том, что фактически они не оцениваются до тех пор, пока не начнется итерация по результирующей последовательности. Формально это называется отложенным выполнением. Преимущество такого подхода связано с возможностью применения одного и того же запроса LINQ многократно к тому же самому контейнеру и полной гарантией получения актуальных результатов. Взгляните на следующее обновление метода
QueryOverlnts()static void QueryOverInts(){ int[] numbers = { 10, 20, 30, 40, 1, 2, 3, 8 }; // Получить числа меньше 10. var subset = from i in numbers where i < 10 select i; // Оператор LINQ здесь оценивается! foreach (var i in subset) { Console.WriteLine("{0} < 10", i); } Console.WriteLine(); // Изменить некоторые данные в массиве. numbers[0] = 4; // Снова производится оценка! foreach (var j in subset) { Console.WriteLine("{0} < 10", j); } Console.WriteLine(); ReflectOverQueryResults(subset);}На заметку! Когда оператор LINQ выбирает одиночный элемент (с использованием
First()/FirstOrDefault()Single()/SingleOrDefault()First()FirstOrDefault()Single()SingleOrDefaultНиже показан вывод, полученный в результате запуска программы. Обратите внимание, что во второй итерации по запрошенной последовательности появился дополнительный член, т.к. для первого элемента массива было установлено значение меньше 10:
1 < 102 < 103 < 108 < 104 < 101 < 102 < 103 < 108 < 10Среда Visual Studio обладает одной полезной особенностью: если вы поместите точку останова перед оценкой запроса LINQ, то получите возможность просматривать содержимое во время сеанса отладки. Просто наведите курсор мыши на переменную результирующего набора LINQ (
subset
Роль немедленного выполнения
Когда требуется оценить выражение LINQ, выдающее последовательность, за пределами логики
foreachEnumerableТоArray<Т>()ToDictionary() ToList() Кроме того, запрос выполняется немедленно в случае поиска только одного элемента. Метод
First()orderbyFirstOrDefault()whereSingle()orderbyorderbySingleOrDefault()whereFirst(OrDefault)Single(OrDefault)Single(OrDefault)static void ImmediateExecution(){ Console.WriteLine(); Console.WriteLine("Immediate Execution"); int[] numbers = { 10, 20, 30, 40, 1, 2, 3, 8 }; // Получить первый элемент в порядке последовательности int number = (from i in numbers select i).First(); Console.WriteLine("First is {0}", number); // Получить первый элемент в порядке запроса number = (from i in numbers orderby i select i).First(); Console.WriteLine("First is {0}", number); // Получить один элемент, который соответствует запросу number = (from i in numbers where i > 30 select i).Single(); Console.WriteLine("Single is {0}", number); try { // В случае возвращения более одного элемента генерируется исключение number = (from i in numbers where i > 10 select i).Single(); } catch (Exception ex) { Console.WriteLine("An exception occurred: {0}", ex.Message); } // Получить данные НЕМЕДЛЕННО как int[]. int[] subsetAsIntArray = (from i in numbers where i < 10 select i).ToArray(); // Получить данные НЕМЕДЛЕННО как List. List subsetAsListOfInts = (from i in numbers where i < 10 select i).ToList(); }Обратите внимание, что для вызова методов
EnumerableВспомните из главы 10, что если компилятор C# в состоянии однозначно определить параметр типа обобщенного элемента, то вы не обязаны указывать этот параметр типа. Следовательно,
ТоArray<Т>()ToList() int[] subsetAsIntArray = (from i in numbers where i < 10 select i).ToArray();Полезность немедленного выполнения очевидна, когда нужно возвратить результаты запроса LINQ внешнему вызывающему коду, что и будет темой следующего раздела главы.
Возвращение результатов запроса LINQ
Внутри класса (или структуры) можно определить поле, значением которого будет результат запроса LINQ. Однако для этого нельзя использовать неявную типизацию (т.к. ключевое слово
varclass LINQBasedFieldsAreClunky{ private static string[] currentVideoGames = {"Morrowind", "Uncharted 2", "Fallout 3", "Daxter", "System Shock 2"}; // Здесь нельзя использовать неявную типизацию! // Тип subset должен быть известен! private IEnumerable subset = from g in currentVideoGames where g.Contains(" ") orderby g select g; public void PrintGames() { foreach (var item in subset) { Console.WriteLine(item); } }}Запросы LINQ часто определяются внутри области действия метода или свойства. Кроме того, для упрощения программирования результирующий набор будет храниться в неявно типизированной локальной переменной, использующей ключевое слово
varИтак, вполне вероятно, вас интересует, каким образом возвратить результат запроса внешнему коду. Ответ: в зависимости от обстоятельств. Если у вас есть результирующий набор, состоящий из строго типизированных данных, такой как массив строк или список
ListCarvarIEnumerableIEnumerableIEnumerableIEnumerableProgramLinqRetValuesusing System;using System.Collections.Generic;using System.Linq;Console.WriteLine("***** LINQ Return Values *****\n");IEnumerable subset = GetStringSubset(); foreach (string item in subset){ Console.WriteLine(item);}Console.ReadLine();static IEnumerable GetStringSubset() { string[] colors = {"Light Red", "Green", "Yellow", "Dark Red", "Red", "Purple"}; // Обратите внимание, что subset является // совместимым с IEnumerable объектом. IEnumerable theRedColors = from c in colors where c.Contains("Red") select c; return theRedColors;}Результат выглядит вполне ожидаемо:
Light RedDark RedRedВозвращение результатов LINQ посредством немедленного выполнения
Рассмотренный пример работает ожидаемым образом только потому, что возвращаемое значение
GetStringSubset()varsubsetIEnumerableПоскольку оперировать с типом
IEnumerableIEnumerablestring[]Programstatic string[] GetStringSubsetAsArray(){ string[] colors = {"Light Red", "Green", "Yellow", "Dark Red", "Red", "Purple"}; var theRedColors = from c in colors where c.Contains("Red") select c; // Отобразить результаты в массив. return theRedColors.ToArray();}В таком случае вызывающий код совершенно не знает, что полученный им результат поступил от запроса LINQ, и просто работает с массивом строк вполне ожидаемым образом. Вот пример:
foreach (string item in GetStringSubsetAsArray()){ Console.WriteLine(item);}Немедленное выполнение также важно при попытке возвратить вызывающему коду результаты проецирования LINQ. Мы исследуем эту тему чуть позже в главе. А сейчас давайте посмотрим, как применять запросы LINQ к обобщенным и необобщенным объектам коллекций.
Применение запросов LINQ к объектам коллекций
Помимо извлечения результатов из простого массива данных выражения запросов LINQ могут также манипулировать данными внутри классов из пространства имен
System.Collections.GenericListListOverCollectionsCarnamespace LinqOverCollections{ class Car { public string PetName {get; set;} = ""; public string Color {get; set;} = ""; public int Speed {get; set;} public string Make {get; set;} = ""; }}Теперь определите внутри операторов верхнего уровня локальную переменную типа
ListCarCarusing System;using System.Collections;using System.Collections.Generic;using System.Linq;using LinqOverCollections;Console.WriteLine("***** LINQ over Generic Collections *****\n");// Создать список List<> объектов Car.List myCars = new List() { new Car{ PetName = "Henry", Color = "Silver", Speed = 100, Make = "BMW"}, new Car{ PetName = "Daisy", Color = "Tan", Speed = 90, Make = "BMW"}, new Car{ PetName = "Mary", Color = "Black", Speed = 55, Make = "VW"}, new Car{ PetName = "Clunker", Color = "Rust", Speed = 5, Make = "Yugo"}, new Car{ PetName = "Melvin", Color = "White", Speed = 43, Make = "Ford"}};Console.ReadLine();Доступ к содержащимся в контейнере подобъектам
Применение запроса LINQ к обобщенному контейнеру ничем не отличается от такого же действия в отношении простого массива, потому что LINQ to Objects может использоваться с любым типом, реализующим интерфейс
IEnumerablemyCarsCar55После получения подмножества на консоль будет выведено имя каждого объекта
CarPetNameListstatic void GetFastCars(List myCars) { // Найти в List<> все объекты Car, у которых значение Speed больше 55. var fastCars = from c in myCars where c.Speed > 55 select c; foreach (var car in fastCars) { Console.WriteLine("{0} is going too fast!", car.PetName); }}Обратите внимание, что выражение запроса захватывает из
ListSpeed55НenryDaisyЧтобы построить более сложный запрос, можно искать только автомобили марки BMW со значением
Speed90&&static void GetFastBMWs(List myCars) { // Найти быстрые автомобили BMW! var fastCars = from c in myCars where c.Speed > 90 && c.Make == "BMW" select c; foreach (var car in fastCars) { Console.WriteLine("{0} is going too fast!", car.PetName); }}Теперь выводится только одно имя
HenryПрименение запросов LINQ к необобщенным коллекциям
Вспомните, что операции запросов LINQ спроектированы для работы с любым типом, реализующим интерфейс
IEnumerableSystem.ArraySystem.CollectionsEnumerable.OfТуре<Т>()При вызове метода
OfТуре<Т>()ArrayListIEnumerableВзгляните на показанный ниже новый метод, который заполняет
ArrayListCarSystem.CollectionsProgram.csstatic void LINQOverArrayList(){ Console.WriteLine("***** LINQ over ArrayList *****"); // Необобщенная коллекция объектов Car. ArrayList myCars = new ArrayList() { new Car{ PetName = "Henry", Color = "Silver", Speed = 100, Make = "BMW"}, new Car{ PetName = "Daisy", Color = "Tan", Speed = 90, Make = "BMW"}, new Car{ PetName = "Mary", Color = "Black", Speed = 55, Make = "VW"}, new Car{ PetName = "Clunker", Color = "Rust", Speed = 5, Make = "Yugo"}, new Car{ PetName = "Melvin", Color = "White", Speed = 43, Make = "Ford"} }; // Трансформировать ArrayList в тип, совместимый c IEnumerable. var myCarsEnum = myCars.OfType(); // Создать выражение запроса, нацеленное на совместимый с IEnumerable тип. var fastCars = from c in myCarsEnum where c.Speed > 55 select c; foreach (var car in fastCars) { Console.WriteLine("{0} is going too fast!", car.PetName); }}Аналогично предшествующим примерам этот метод, вызванный в операторах верхнего уровня, отобразит только имена
HenryDaisyФильтрация данных с использованием метода OfТуре<Т>()
Как вы уже знаете, необобщенные типы способны содержать любые комбинации элементов, поскольку члены этих контейнеров (вроде
ArrayListSystem.ObjectArrayListOfТуре<Т>()static void OfTypeAsFilter(){ // Извлечь из ArrayList целочисленные значения. ArrayList myStuff = new ArrayList(); myStuff.AddRange(new object[] { 10, 400, 8, false, new Car(), "string data" }); var myInts = myStuff.OfType(); // Выводит 10, 400 и 8. foreach (int i in myInts) { Console.WriteLine("Int value: {0}", i); }}К настоящему моменту вы уже умеете применять запросы LINQ к массивам, а также обобщенным и необобщенным коллекциям. Контейнеры подобного рода содержат элементарные типы C# (целочисленные и строковые данные) и специальные классы. Следующей задачей будет изучение многочисленных дополнительных операций LINQ, которые могут использоваться для построения более сложных и полезных запросов.
Исследование операций запросов LINQ
В языке C# предопределено порядочное число операций запросов. Некоторые часто применяемые из них перечислены в табл. 13.2. В дополнение к неполному списку операций, приведенному в табл. 13.3, класс
System.Linq.EnumerableReverse<>()ToArray<>()ToList<>()Distinct<>()Union<>()Intersect<>()Count<>()Sum<>()Min<>()Мах<>()
Чтобы приступить к исследованию более замысловатых запросов LINQ, создайте новый проект консольного приложения по имени
FunWithLinqExpressionsFunWithLinqExpressionsProductInfonamespace FunWithLinqExpressions{ class ProductInfo { public string Name {get; set;} = ""; public string Description {get; set;} = ""; public int NumberInStock {get; set;} = 0; public override string ToString() => $"Name={Name}, Description={Description}, Number in Stock={NumberInStock}"; }}Теперь заполните массив объектами
ProductInfoConsole.WriteLine("***** Fun with Query Expressions *****\n");// Этот массив будет основой для тестирования...ProductInfo[] itemsInStock = new[] { new ProductInfo{ Name = "Mac's Coffee", Description = "Coffee with TEETH", NumberInStock = 24}, new ProductInfo{ Name = "Milk Maid Milk", Description = "Milk cow's love", NumberInStock = 100}, new ProductInfo{ Name = "Pure Silk Tofu", Description = "Bland as Possible", NumberInStock = 120}, new ProductInfo{ Name = "Crunchy Pops", Description = "Cheezy, peppery goodness", NumberInStock = 2}, new ProductInfo{ Name = "RipOff Water", Description = "From the tap to your wallet", NumberInStock = 100}, new ProductInfo{ Name = "Classic Valpo Pizza", Description = "Everyone loves pizza!", NumberInStock = 73}};// Здесь мы будем вызывать разнообразные методы!Console.ReadLine();Базовый синтаксис выборки
Поскольку синтаксическая корректность выражения запроса LINQ проверяется на этапе компиляции, вы должны помнить, что порядок следования операций критически важен. В простейшем виде каждый запрос LINQ строится с использованием операций
frominselectvar результат = from сопоставляемыйЭлемент in контейнер select сопоставляемыйЭлемент;Элемент после операции
fromРассмотрим простой запрос, не делающий ничего кроме извлечения каждого элемента контейнера (по поведению похожий на SQL-оператор
SELECT *static void SelectEverything(ProductInfo[] products){ // Получить все! Console.WriteLine("All product details:"); var allProducts = from p in products select p; foreach (var prod in allProducts) { Console.WriteLine(prod.ToString()); }}По правде говоря, это выражение запроса не особенно полезно, т.к. оно выдает подмножество, идентичное содержимому входного параметра. При желании можно извлечь только значения
Namestatic void ListProductNames(ProductInfo[] products){ // Теперь получить только наименования товаров. Console.WriteLine("Only product names:"); var names = from p in products select p.Name; foreach (var n in names) { Console.WriteLine("Name: {0}", n); }}Получение подмножества данных
Чтобы получить определенное подмножество из контейнера, можно использовать операцию
wherevar результат = from элемент in контейнер where булевскоеВыражение select элемент;Обратите внимание, что операция where ожидает выражение, результатом вычисления которого является булевское значение. Например, чтобы извлечь из аргумента
ProductInfo[]static void GetOverstock(ProductInfo[] products){ Console.WriteLine("The overstock items!"); // Получить только товары со складским запасом более 25 единиц. var overstock = from p in products where p.NumberInStock > 25 select p; foreach (ProductInfo c in overstock) { Console.WriteLine(c.ToString()); }}Как демонстрировалось ранее в главе, при указании конструкции
where// Получить автомобили BMW, движущиеся со скоростью минимум 90 миль в час.var onlyFastBMWs = from c in myCars where c.Make == "BMW" && c.Speed >= 100 select c;Проецирование в новые типы данных
Новые формы данных также можно проецировать из существующего источника данных. Давайте предположим, что необходимо принять входной параметр
ProductInfo[]selectstatic void GetNamesAndDescriptions(ProductInfo[] products){ Console.WriteLine("Names and Descriptions:"); var nameDesc = from p in products select new { p.Name, p.Description }; foreach (var item in nameDesc) { // Можно было бы также использовать свойства Name // и Description напрямую. Console.WriteLine(item.ToString()); }}Не забывайте, что когда запрос LINQ использует проекцию, нет никакого способа узнать лежащий в ее основе тип данных, т.к. он определяется на этапе компиляции. В подобных случаях ключевое слово
varstatic var GetProjectedSubset(ProductInfo[] products){ var nameDesc = from p in products select new { p.Name, p.Description }; return nameDesc; // Так поступать нельзя!}В случае необходимости возвращения спроецированных данных вызывающему коду один из подходов предусматривает трансформацию результата запроса в объект
System.ArrayТоArray()// Теперь возвращаемым значением является объект Array.static Array GetProjectedSubset(ProductInfo[] products){ var nameDesc = from p in products select new { p.Name, p.Description }; // Отобразить набор анонимных объектов на объект Array. return nameDesc.ToArray();}метод
GetProjectedSubset()Array objs = GetProjectedSubset(itemsInStock);foreach (object o in objs){ Console.WriteLine(o); // Вызывает метод ToString() // на каждом анонимном объекте.}Как видите, здесь должен использоваться буквальный объект
System.ArrayToArray<Т>()Очевидная проблема связана с утратой строгой типизации, т.к. каждый элемент в объекте
ArrayObjectArrayEnumerableПроецирование в другие типы данных
В дополнение к проецированию в анонимные типы результаты запроса LINQ можно проецировать в другой конкретный тип, что позволяет применять статическую типизацию и реализацию
IEnumerableProductInfonamespace FunWithLinqExpressions{ class ProductInfoSmall { public string Name {get; set;} = ""; public string Description {get; set;} = ""; public override string ToString() => $"Name={Name}, Description={Description}"; }}Следующее изменение касается проецирования результатов запроса в коллекцию объектов
ProductInfoSmallProductInfoSmallstatic void GetNamesAndDescriptionsTyped( ProductInfo[] products){ Console.WriteLine("Names and Descriptions:"); IEnumerable 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()Enumerablestringstatic 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() EnumerableProductInfo[]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()); }}Выражения сортировки
В начальных примерах настоящей главы вы видели, что в выражении запроса может использоваться операция
orderbydescendingstatic 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()); }}Хотя порядок по возрастанию является стандартным, свои намерения можно прояснить, явно указав операцию
ascendingvar subset = from p in products orderby p.Name ascending select p;Для получения элементов в порядке убывания служит операция
descendingvar subset = from p in products orderby p.Name descending select p;LINQ как лучшее средство построения диаграмм Венна
Класс
EnumerableExcept()Yugostatic void DisplayDiff(){ List myCars = new List {"Yugo", "Aztec", "BMW"}; List yourCars = new List{"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()AztecBMWstatic void DisplayIntersection(){ List myCars = new List { "Yugo", "Aztec", "BMW" }; List yourCars = new List { "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()YugoAztecBMWSaabstatic void DisplayUnion(){ List myCars = new List { "Yugo", "Aztec", "BMW" }; List yourCars = new List { "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()YugoAztecBMWSaabAztecstatic void DisplayConcat(){ List myCars = new List { "Yugo", "Aztec", "BMW" }; List yourCars = new List { "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 s in carConcat) { Console.WriteLine(s); }}Устранение дубликатов
При вызове расширяющего метода
Concat()Distinct()static void DisplayConcatNoDups(){ List myCars = new List { "Yugo", "Aztec", "BMW" }; List yourCars = new List { "BMW", "Saab", "Aztec" }; var carConcat = (from c in myCars select c) .Concat(from c2 in yourCars select c2); // Выводит Yugo Aztec BMW Saab. foreach (string s in carConcat.Distinct()) { Console.WriteLine(s); }}Операции агрегирования LINQ
Запросы LINQ могут также проектироваться для выполнения над результирующим набором разнообразных операций агрегирования. Одним из примеров может служить расширяющий метод
Count()Average()Мах()Min()Sum()EnumerableHere is a simple example:static void AggregateOps() { double[] winterTemps = { 2.0, -21.3, 8, -4, 0, 8.2 }; // Разнообразные примеры агрегации. // Выводит максимальную температуру: Console.WriteLine("Max temp: {0}", (from t in winterTemps select t).Max()); // Выводит минимальную температуру: Console.WriteLine("Min temp: {0}", (from t in winterTemps select t).Min()); // Выводит среднюю температуру: Console.WriteLine("Average temp: {0}", (from t in winterTemps select t).Average()); // Выводит сумму всех температур: Console.WriteLine("Sum of all temps: {0}", (from t in winterTemps select t).Sum()); } Приведенные примеры должны предоставить достаточный объем сведений, чтобы вы освоились с процессом построения выражений запросов LINQ. Хотя существуют дополнительные операции, которые пока еще не рассматривались, вы увидите примеры позже в книге, когда речь пойдет о связанных технологиях LINQ. В завершение вводного экскурса в LINQ оставшиеся материалы главы посвящены подробностям отношений между операциями запросов LINQ и лежащей в основе объектной моделью.
Внутреннее представление операторов запросов LINQ
К настоящему моменту вы уже знакомы с процессом построения выражений запросов с применением разнообразных операций запросов C# (таких как
frominwhereorderbyselectEnumerableEnumerableОгромное количество методов класса
EnumerableFunс<>Where()Enumerablewhere// Перегруженные версии метода Enumerable.Where(). // Обратите внимание, что второй параметр имеет тип System.Func<>.public static IEnumerable Where( this IEnumerable source, System.Func predicate) public static IEnumerable Where( this IEnumerable source, System.Func predicate) Делегат
Func<>Func<>// Различные формы делегата Func<>.public delegate TResult Func (T1 arg1, T2 arg2, T3 arg3, T4 arg4)public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3) public delegate TResult Func(T1 arg1, T2 arg2) public delegate TResult Func(T1 arg1) public delegate TResult Func() Учитывая, что многие члены класса
System.Linq.EnumerableХотя использование операций запросов LINQ является, несомненно, самым простым способом построения запросов LINQ, давайте взглянем на все возможные подходы, чтобы увидеть связь между операциями запросов C# и лежащим в основе типом
EnumerableПостроение выражений запросов с применением операций запросов
Для начала создадим новый проект консольного приложения по имени
LinqUsingEnumerableProgramПервый метод,
QueryStringsWithOperators()LinqOverArrayusing System.Linq;static void QueryStringWithOperators(){ Console.WriteLine("***** Using Query Operators *****"); string[] currentVideoGames = {"Morrowind", "Uncharted 2", "Fallout 3", "Daxter", "System Shock 2"}; var subset = from game in currentVideoGames where game.Contains(" ") orderby game select game; foreach (string s in subset) { Console.WriteLine("Item: {0}", s); }}Очевидное преимущество использования операций запросов C# при построении выражений запросов заключается в том, что делегаты
Funс<>EnumerablefrominwhereorderbyПостроение выражений запросов с использованием типа Enumerable и лямбда-выражений
Имейте в виду, что применяемые здесь операции запросов LINQ представляют собой сокращенные версии вызова расширяющих методов, определенных в типе
EnumerableQueryStringsWithEnumerableAndLambdas()Enumerablestatic void QueryStringsWithEnumerableAndLambdas(){ Console.WriteLine("***** Using Enumerable / Lambda Expressions *****"); string[] currentVideoGames = {"Morrowind", "Uncharted 2", "Fallout 3", "Daxter", "System Shock 2"}; // Построить выражение запроса с использованием расширяющих методов, // предоставленных типу Array через тип Enumerable. var subset = currentVideoGames .Where(game => game.Contains(" ")) .OrderBy(game => game).Select(game => game); // Вывести результаты. foreach (var game in subset) { Console.WriteLine("Item: {0}", game); } Console.WriteLine();}Здесь сначала вызывается расширяющий метод
Where()currentVideoGamesArrayEnumerableEnumerable.Where()System.FuncIEnumerableВозвращаемое значение метода
Where()OrderedEnumerableOrderBy()Func<>OrderBy()И, наконец, осуществляется вызов метода
Select()OrderBy()subsetКонечно, такой "длинный" запрос LINQ несколько сложнее для восприятия, чем предыдущий пример с операциями запросов LINQ. Без сомнения, часть сложности связана с объединением в цепочку вызовов посредством операции точки. Вот тот же самый запрос с выделением каждого шага в отдельный фрагмент (разбивать запрос на части можно разными способами):
static void QueryStringsWithEnumerableAndLambdas2(){ Console.WriteLine("***** Using Enumerable / Lambda Expressions *****"); string[] currentVideoGames = {"Morrowind", "Uncharted 2", "Fallout 3", "Daxter", "System Shock 2"}; // Разбить на части. var gamesWithSpaces = currentVideoGames.Where(game => game.Contains(" ")); var orderedGames = gamesWithSpaces.OrderBy(game => game); var subset = orderedGames.Select(game => game); foreach (var game in subset) { Console.WriteLine("Item: {0}", game); } Console.WriteLine();}Как видите, построение выражения запроса LINQ с применением методов класса
EnumerableEnumerableПостроение выражений запросов с использованием типа Enumerable и анонимных методов
Учитывая, что лямбда-выражения C# — это просто сокращенный способ работы с анонимными методами, рассмотрим третье выражение запроса внутри вспомогательного метода
QueryStringsWithAnonymousMethods()static void QueryStringsWithAnonymousMethods(){ Console.WriteLine("***** Using Anonymous Methods *****"); string[] currentVideoGames = {"Morrowind", "Uncharted 2", "Fallout 3", "Daxter", "System Shock 2"}; // Построить необходимые делегаты Func<> // с использованием анонимных методов. Func searchFilter = delegate(string game) { return game.Contains(" "); }; Func itemToProcess = delegate(string s) { return s; }; // Передать делегаты в методы класса Enumerable. var subset = currentVideoGames.Where(searchFilter).OrderBy(itemToProcess). Select(itemToProcess); // Вывести результаты. foreach (var game in subset) { Console.WriteLine("Item: {0}", game); } Console.WriteLine();}Такой вариант выражения запроса оказывается еще более многословным из-за создания вручную делегатов
Func<>Where()OrderBy()Select()EnumerableQueryStringsWithEnumerableAndLambdas()QueryStringsWithOperators()Построение выражений запросов с использованием типа Enumerable и низкоуровневых делегатов
Наконец, если вы хотите строить выражение запроса с применением многословного подхода, то можете отказаться от использования синтаксиса лямбда-выражений и анонимных методов и напрямую создавать цели делегатов для каждого типа
Func<>VeryComplexQueryExpressionclass VeryComplexQueryExpression{ public static void QueryStringsWithRawDelegates() { Console.WriteLine("***** Using Raw Delegates *****"); string[] currentVideoGames = {"Morrowind", "Uncharted 2", "Fallout 3", "Daxter", "System Shock 2"}; // Построить необходимые делегаты Func<>. Func searchFilter = new Func(Filter); Func itemToProcess = new Func(ProcessItem); // Передать делегаты в методы класса Enumerable. var subset = currentVideoGames .Where(searchFilter) .OrderBy(itemToProcess) .Select(itemToProcess); // Вывести результаты. foreach (var game in subset) { Console.WriteLine("Item: {0}", game); } Console.WriteLine(); } // Цели делегатов. public static bool Filter(string game) { return game.Contains(" "); } public static string ProcessItem(string game) { return game; }}Чтобы протестировать такую версию логики обработки строк, метод
QueryStringsWithRawDelegates()ProgramVeryComplexQueryExpression.QueryStringsWithRawDelegates();Если теперь запустить приложение, чтобы опробовать все возможные подходы, вывод окажется идентичным независимо от выбранного пути. Запомните перечисленные ниже моменты относительно выражений запросов и их внутреннего представления.
• Выражения запросов создаются с применением разнообразных операций запросов С# .
• Операции запросов — это просто сокращенное обозначение для вызова расширяющих методов, определенных в типе
System.Linq.Enumerable• Многие методы класса
EnumerableFunc<>• Любой метод, ожидающий параметра типа делегата, может принимать вместо него лямбда-выражение.
• Лямбда-выражения являются всего лишь замаскированными анонимными методами (и значительно улучшают читабельность).
• Анонимные методы представляют собой сокращенные обозначения для размещения экземпляра низкоуровневого делегата и ручного построения целевого метода делегата.
Хотя здесь мы погрузились в детали чуть глубже, чем возможно хотелось, приведенное обсуждение должно было способствовать пониманию того, что фактически делают "за кулисами" дружественные к пользователю операции запросов С#.
Резюме
LINQ — это набор взаимосвязанных технологий, которые были разработаны для предоставления единого и симметричного стиля взаимодействия с данными несходных форм. Как объяснялось в главе, LINQ может взаимодействовать с любым типом, реализующим интерфейс
IEnumerableБыло показано, что работа с технологиями LINQ обеспечивается несколькими средствами языка С#. Например, учитывая тот факт, что выражения запросов LINQ могут возвращать любое количество результирующих наборов, для представления лежащего в основе типа данных принято использовать ключевое слово
varБолее важно то, что операции запросов LINQ в C# на самом деле являются просто сокращенными обозначениями для обращения к статическим членам типа
System.Linq.EnumerableEnumerableFuncГлава 14 Процессы, домены приложении и контексты загрузки
В настоящей главе будут представлены детали обслуживания сборки исполняющей средой, а также отношения между процессами, доменами приложений и контекстами загрузки.
Выражаясь кратко, домены приложений (Application Domain или просто AppDomain) представляют собой логические подразделы внутри заданного процесса, обслуживающего набор связанных сборок .NET Core. Как вы увидите, каждый домен приложения в дальнейшем подразделяется на контекстные границы, которые используются для группирования вместе похожих по смыслу объектов .NET Core. Благодаря понятию контекста исполняющая среда способна обеспечивать надлежащую обработку объектов со специальными требованиями.
Хотя вполне справедливо утверждать, что многие повседневные задачи программирования не предусматривают работу с процессами, доменами приложений или контекстами загрузки напрямую, их понимание важно при взаимодействии с многочисленными API-интерфейсами .NET Core, включая многопоточную и параллельную обработку, а также сериализацию объектов.
Роль процесса Windows
Концепция "процесса" существовала в операционных системах Windows задолго до выпуска платформы .NET/.NET Core. Пользуясь простыми терминами, процесс — это выполняющаяся программа. Тем не менее, формально процесс является концепцией уровня операционной системы, которая применяется для описания набора ресурсов (таких как внешние библиотеки кода и главный поток) и необходимых распределений памяти, используемой функционирующим приложением. Для каждого загруженного в память приложения .NET Core операционная система создает отдельный изолированный процесс для применения на протяжении всего времени его существования.
При использовании такого подхода к изоляции приложений в результате получается намного более надежная и устойчивая исполняющая среда, поскольку отказ одного процесса не влияет на работу других процессов. Более того, данные в одном процессе не доступны напрямую другим процессам, если только не применяются специфичные инструменты вроде пространства имен
System.IO.PipesMemoryMappedFileКаждый процесс Windows получает уникальный идентификатор процесса (process identifier — PID) и может по мере необходимости независимо загружаться и выгружаться операционной системой (а также программно). Как вам возможно известно, в окне диспетчера задач Windows (открываемом по нажатию комбинации клавиш <Ctrl+Shift+Esc>) имеется вкладка Processes (Процессы), на которой можно просматривать разнообразные статические данные о процессах, функционирующих на машине. На вкладке Details (Подробности) можно видеть назначенный идентификатор PID и имя образа (рис. 14.1).
Роль потоков
Каждый процесс Windows содержит начальный "поток", который действует как точка входа для приложения. Особенности построения многопоточных приложений на платформе .NET Core рассматриваются в главе 15; однако для понимания материала настоящей главы необходимо ознакомиться с несколькими рабочими определениями. Поток представляет собой путь выполнения внутри процесса. Выражаясь формально, первый поток, созданный точкой входа процесса, называется главным потоком. В любой программе .NET Core (консольном приложении, Windows-службе, приложении WPF и т.д.) точка входа помечается с помощью метода
Main()Процессы, которые содержат единственный главный поток выполнения, по своей сути безопасны в отношении потоков, т.к. в каждый момент времени доступ к данным приложения может получать только один поток. Тем не менее, однопоточный процесс (особенно с графическим пользовательским интерфейсом) часто замедленно реагирует на действия пользователя, когда его единственный поток выполняет сложную операцию (наподобие печати длинного текстового файла, сложных математических вычислений или попытки подключения к удаленному серверу, находящемуся на расстоянии тысяч километров).
Учитывая такой потенциальный недостаток однопоточных приложений, операционные системы, которые поддерживаются .NET Core, и сама платформа .NET Core предоставляют главному потоку возможность порождения дополнительных вторичных потоков (называемых рабочими потоками) с использованием нескольких функций из API-интерфейса Windows, таких как
CreateThread()Нетрудно догадаться, что разработчики обычно создают дополнительные потоки для улучшения общей степени отзывчивости программы. Многопоточные процессы обеспечивают иллюзию того, что выполнение многочисленных действий происходит более или менее одновременно. Например, приложение может порождать дополнительный рабочий поток для выполнения трудоемкой единицы работы (вроде вывода на печать крупного текстового файла). После запуска вторичного потока главный поток продолжает реагировать на пользовательский ввод, что дает всему процессу возможность достигать более высокой производительности. Однако на самом деле так происходит не всегда: применение слишком большого количества потоков в одном процессе может приводить к ухудшению производительности из-за того, что центральный процессор должен переключаться между активными потоками внутри процесса (а это отнимает время).
На некоторых машинах многопоточность по большей части является иллюзией, обеспечиваемой операционной системой. Машины с единственным (не поддерживающим гиперпотоки) центральным процессором не обладают возможностью обработки множества потоков в одно и то же время. Взамен один центральный процессор выполняет по одному потоку за единицу времени (называемую квантом времени), частично основываясь на приоритете потока. По истечении выделенного кванта времени выполнение существующего потока приостанавливается, позволяя выполнять работу другому потоку. Чтобы поток не "забывал", что происходило до того, как его выполнение было приостановлено, ему предоставляется возможность записывать данные в локальное хранилище потоков (Thread Local Storage — TLS) и выделяется отдельный стек вызовов (рис. 14.2).
Если тема потоков для вас нова, то не стоит беспокоиться о деталях. На данном этапе просто запомните, что любой поток представляет собой уникальный путь выполнения внутри процесса Windows. Каждый процесс имеет главный поток (созданный посредством точки входа исполняемого файла) и может содержать дополнительные потоки, которые создаются программно.
Взаимодействие с процессами используя платформу .NET Core
Несмотря на то что с процессами и потоками не связано ничего нового, способ взаимодействия с ними в рамках платформы .NET Core значительно изменился (в лучшую сторону). Чтобы подготовить почву для понимания области построения многопоточных сборок (см. главу 15), давайте начнем с выяснения способов взаимодействия с процессами, используя библиотеки базовых классов .NET Core.
В пространстве имен
System.Diagnostics
Класс
System.Diagnostics.ProcessProcessSystem.Diagnostics.Process
Кроме перечисленных выше свойств в классе
System.Diagnostics.Process
Перечисление выполняющихся процессов
Для иллюстрации способа манипулирования объектами
ProcessProcessManipulatorProgramSystem.DiagnosticsSystem.Linqstatic void ListAllRunningProcesses(){ // Получить все процессы на локальной машине, упорядоченные по PID. var runningProcs = from proc in Process.GetProcesses(".") orderby proc.Id select proc; // Вывести для каждого процесса идентификатор PID и имя. foreach(var p in runningProcs) { string info = $"-> PID: {p.Id}\tName: {p.ProcessName}"; Console.WriteLine(info); } Console.WriteLine("************************************\n");}Статический метод
Process.GetProcesses()Process.Processusing System;using System.Diagnostics;using System.Linq;Console.WriteLine("***** Fun with Processes *****\n");ListAllRunningProcesses();Console.ReadLine();Запустив приложение, вы увидите список имен и идентификаторов PID для всех процессов на локальной машине. Ниже показана часть вывода (ваш вывод наверняка будет отличаться):
***** Fun with Processes *****-> PID: 0 Name: Idle-> PID: 4 Name: System-> PID: 104 Name: Secure System-> PID: 176 Name: Registry-> PID: 908 Name: svchost-> PID: 920 Name: smss-> PID: 1016 Name: csrss-> PID: 1020 Name: NVDisplay.Container-> PID: 1104 Name: wininit-> PID: 1112 Name: csrss************************************Исследование конкретного процесса
В дополнение к полному списку всех выполняющихся процессов на заданной машине статический метод
Process.GetProcessById()ProcessArgumentExceptionProcess// Если процесс с PID, равным 30592, не существует,// то сгенерируется исключение во время выполнения.static void GetSpecificProcess(){ Process theProc = null; try { theProc = Process.GetProcessById(30592); } catch(ArgumentException ex) { Console.WriteLine(ex.Message); }}К настоящему моменту вы уже знаете, как получить список всех процессов, а также специфический процесс на машине посредством поиска по PID. Наряду с выяснением идентификаторов PID и имен процессов класс
ProcessИсследование набора потоков процесса
Набор потоков представлен в виде строго типизованной коллекции
ProcessThreadCollectionProcessThreadstatic void EnumThreadsForPid(int pID){ Process theProc = null; try { theProc = Process.GetProcessById(pID); } catch(ArgumentException ex) { Console.WriteLine(ex.Message); return; } // Вывести статистические сведения по каждому потоку // в указанном процессе. Console.WriteLine( "Here are the threads used by: {0}", theProc.ProcessName); ProcessThreadCollection theThreads = theProc.Threads; foreach(ProcessThread pt in theThreads) { string info = $"-> Thread ID: {pt.Id}\tStart Time: {pt.StartTime.ToShortTimeString()}\tPriority: {pt.PriorityLevel}"; Console.WriteLine(info); } Console.WriteLine("************************************\n");}Как видите, свойство
ThreadsSystem.Diagnostics.ProcessProcessThreadCollection...// Запросить у пользователя PID и вывести набор активных потоков.Console.WriteLine("***** Enter PID of process to investigate *****");Console.Write("PID: ");string pID = Console.ReadLine();int theProcID = int.Parse(pID);EnumThreadsForPid(theProcID);Console.ReadLine();После запуска приложения можно вводить PID любого процесса на машине и просматривать имеющиеся внутри него потоки. В следующем выводе показан неполный список потоков, используемых процессом с PID 3804, который (так случилось) обслуживает браузер Edge:
***** Enter PID of process to investigate *****PID: 3804Here are the threads used by: msedge-> Thread ID: 3464 Start Time: 01:20 PM Priority: Normal-> Thread ID: 19420 Start Time: 01:20 PM Priority: Normal-> Thread ID: 17780 Start Time: 01:20 PM Priority: Normal-> Thread ID: 22380 Start Time: 01:20 PM Priority: Normal-> Thread ID: 27580 Start Time: 01:20 PM Priority: -4…************************************Помимо
IdStartTimePriorityLevelProcessThread
Прежде чем двигаться дальше, необходимо уяснить, что тип
ProcessThreadProcessThreadSystem.ThreadingИсследование набора модулей процесса
Теперь давайте посмотрим, как реализовать проход по загруженным модулям, которые размещены внутри конкретного процесса. Когда речь идет о процессах, модуль — это общий термин, применяемый для описания заданной сборки
*.dll*.ехеProcessModuleCollectionProcess.Modulesstatic void EnumModsForPid(int pID){ Process theProc = null; try { theProc = Process.GetProcessById(pID); } catch(ArgumentException ex) { Console.WriteLine(ex.Message); return; } Console.WriteLine("Here are the loaded modules for: {0}", theProc.ProcessName); ProcessModuleCollection theMods = theProc.Modules; foreach(ProcessModule pm in theMods) { string info = $"-> Mod Name: {pm.ModuleName}"; Console.WriteLine(info); } Console.WriteLine("************************************\n");}Чтобы получить какой-то вывод, давайте просмотрим загружаемые модули для процесса, обслуживающего программу текущего примера (
ProcessManipulatorProcessManipulator.exeEnumModsForPid()*.dllGDI32.dllUSER32.dllole32.dllHere are (some of) the loaded modules for: ProcessManipulatorHere are the loaded modules for: ProcessManipulator-> Mod Name: ProcessManipulator.exe-> Mod Name: ntdll.dll-> Mod Name: KERNEL32.DLL-> Mod Name: KERNELBASE.dll-> Mod Name: USER32.dll-> Mod Name: win32u.dll-> Mod Name: GDI32.dll-> Mod Name: gdi32full.dll-> Mod Name: msvcp_win.dll-> Mod Name: ucrtbase.dll-> Mod Name: SHELL32.dll-> Mod Name: ADVAPI32.dll-> Mod Name: msvcrt.dll-> Mod Name: sechost.dll-> Mod Name: RPCRT4.dll-> Mod Name: IMM32.DLL-> Mod Name: hostfxr.dll-> Mod Name: hostpolicy.dll-> Mod Name: coreclr.dll-> Mod Name: ole32.dll-> Mod Name: combase.dll-> Mod Name: OLEAUT32.dll-> Mod Name: bcryptPrimitives.dll-> Mod Name: System.Private.CoreLib.dll...************************************Запуск и останов процессов программным образом
Финальными аспектами класса
System.Diagnostics.ProcessStart()Kill()StartAndKillProcess()На заметку! В зависимости от настроек операционной системы, касающихся безопасности для запуска новых процессов могут требоваться права администратора.
static void StartAndKillProcess(){ Process proc = null; // Запустить Edge и перейти на Facebook! try { proc = Process.Start(@"C:\Program Files (x86)\Microsoft\Edge\Application\msedge.exe", "www.facebook.com"); } catch (InvalidOperationException ex) { Console.WriteLine(ex.Message); } // Уничтожить процесс по нажатию . Console.Write("--> Hit enter to kill {0}...", proc.ProcessName); Console.ReadLine(); // Уничтожить все процессы msedge.exe. try { foreach (var p in Process.GetProcessesByName("MsEdge")) { p.Kill(true); } } catch (InvalidOperationException ex) { Console.WriteLine(ex.Message); }}Статический метод
Process.Start()Start()В результате вызова метода
Start()Kill()Start()Kill()try/catchInvalidOperationExceptionKill()Kill()На заметку! В .NET Framework (до выхода .NET Core) для запуска процесса методу
Process.Start()msedgeProcessStartInfoУправление запуском процесса с использованием класса ProcessStartInfo
Метод
Process.Start()System.Diagnostics.ProcessStartInfoProcessStartInfopublic sealed class ProcessStartInfo : object{ public ProcessStartInfo(); public ProcessStartInfo(string fileName); public ProcessStartInfo(string fileName, string arguments); public string Arguments { get; set; } public bool CreateNoWindow { get; set; } public StringDictionary EnvironmentVariables { get; } public bool ErrorDialog { get; set; } public IntPtr ErrorDialogParentHandle { get; set; } public string FileName { get; set; } public bool LoadUserProfile { get; set; } public SecureString Password { get; set; } public bool RedirectStandardError { get; set; } public bool RedirectStandardInput { get; set; } public bool RedirectStandardOutput { get; set; } public Encoding StandardErrorEncoding { get; set; } public Encoding StandardOutputEncoding { get; set; } public bool UseShellExecute { get; set; } public string Verb { get; set; } public string[] Verbs { get; } public ProcessWindowStyle WindowStyle { get; set; } public string WorkingDirectory { get; set; }}Чтобы опробовать настройку запуска процесса, модифицируйте метод
StartAndKillProcess()www.facebook.comMsEdgestatic void StartAndKillProcess(){ Process proc = null; // Запустить Microsoft Edge и перейти на сайт Facebook // с развернутым на весь экран окном. try { ProcessStartInfo startInfo = new ProcessStartInfo("MsEdge", "www.facebook.com"); startInfo.UseShellExecute = true; proc = Process.Start(startInfo); } catch (InvalidOperationException ex) { Console.WriteLine(ex.Message); } ...}В .NET Core свойство
UseShellExecutefalsetrueProcess.Start()ProcessStartInfoUseShellExecutetrueProcess.Start("msedge")Использование команд операционной системы с классом ProcessStartInfo
Помимо применения ярлыков операционной системы для запуска приложений с классом
ProcessStartInfoProcessStartInfostatic void UseApplicationVerbs(){ int i = 0; // Укажите здесь фактический путь и имя документа на своей машине ProcessStartInfo si = new ProcessStartInfo(@"..\TestPage.docx"); foreach (var verb in si.Verbs) { Console.WriteLine($" {i++}. {verb}"); } si.WindowStyle = ProcessWindowStyle.Maximized; si.Verb = "Edit"; si.UseShellExecute = true; Process.Start(si);}Первая часть кода выводит все команды, доступные для документа Word:
***** Fun with Processes ***** 0. Edit 1. OnenotePrintto 2. Open 3. OpenAsReadOnly 4. Print 5. Printto 6. ViewProtectedПосле установки
WindowStyleMaximizedVerbEditPrintТеперь, когда вы понимаете роль процессов Windows и знаете способы взаимодействия с ними из кода С#, можно переходить к исследованию концепции доменов приложений .NET.
На заметку! Каталог, в котором выполняется приложение, зависит от того, как вы его запускаете. Если вы применяете команду
dotnet run.\bin\debug\net5.0Домены приложений .NET
На платформах .NET и .NET Core исполняемые файлы не размещаются прямо внутри процесса Windows, как в случае традиционных неуправляемых приложений. Взамен исполняемый файл .NET и .NET Core попадает в отдельный логический раздел внутри процесса, который называется доменом приложения. Такое дополнительное разделение традиционного процесса Windows обеспечивает несколько преимуществ.
• Домены приложений являются ключевым аспектом нейтральной к операционным системам природы платформы .NET Core, поскольку такое логическое разделение абстрагирует отличия в том, как лежащая в основе операционная система представляет загруженный исполняемый файл.
• Домены приложений оказываются гораздо менее затратными в смысле вычислительных ресурсов и памяти по сравнению с полноценными процессами. Таким образом, среда CoreCLR способна загружать и выгружать домены приложений намного быстрее, чем формальный процесс, и может значительно улучшить масштабируемость серверных приложений.
Отдельный домен приложения полностью изолирован от других доменов приложений внутри процесса. Учитывая такой факт, имейте в виду, что приложение, выполняющееся в одном домене приложения, не может получать данные любого рода (глобальные переменные или статические поля) из другого домена приложения, если только не применяется какой-нибудь протокол распределенного программирования.
На заметку! Поддержка доменов приложений в .NET Core изменилась. В среде .NET Core существует в точности один домен приложения. Создавать новые домены приложений больше нельзя, поскольку это требует поддержки со стороны исполняющей среды и в общем случае сопряжено с высокими накладными расходами. Изоляцию сборок в .NET Core обеспечивает класс
ApplicationLoadContextКласс System.AppDomain
С выходом версии .NET Core класс
AppDomainВзаимодействие со стандартным доменом приложения
С помощью статического свойства
AppDomain.CurrentDomainAppDomainЧтобы научиться взаимодействовать со стандартным доменом приложения, начните с создания нового проекта консольного приложения по имени
DefaultAppDomainAppProgram.csAppDomainusing System;using System.IO;using System.Linq;using System.Reflection;using System.Runtime.Loader;Console.WriteLine("***** Fun with the default AppDomain *****\n");DisplayDADStats();Console.ReadLine();static void DisplayDADStats(){ // Получить доступ к домену приложения для текущего потока. AppDomain defaultAD = AppDomain.CurrentDomain; // Вывести разнообразные статистические данные об этом домене. Console.WriteLine("Name of this domain: {0}",defaultAD.FriendlyName); // Дружественное имя этого домена Console.WriteLine("ID of domain in this process: {0}",defaultAD.Id); // Идентификатор этого процесса Console.WriteLine("Is this the default domain?: {0}", defaultAD.IsDefaultAppDomain()); // Является ли этот домен стандартным Console.WriteLine("Base directory of this domain: {0}", defaultAD.BaseDirectory); // Базовый каталог этого домена Console.WriteLine("Setup Information for this domain:"); // Информация о настройке этого домена Console.WriteLine("\tApplication Base: {0}", defaultAD.SetupInformation.ApplicationBase); // Базовый каталог приложения Console.WriteLine("\t Target Framework: {0}", defaultAD.SetupInformation.TargetFrameworkName); // Целевая платформа}Ниже приведен вывод:
***** Fun with the default AppDomain *****Name of this domain: DefaultAppDomainAppID of domain in this process: 1Is this the default domain?: TrueBase directory of this domain: C:\GitHub\Books\csharp8-wf\Code\Chapter_14\DefaultAppDomainApp\DefaultAppDomainApp\bin\Debug\net5.0\Setup Information for this domain: Application Base: C:\GitHub\Books\csharp8-wf\Code\Chapter_14\ DefaultAppDomainApp\ DefaultAppDomainApp\bin\Debug\net5.0\ Target Framework: .NETCoreApp,Version=v5.0Обратите внимание, что имя стандартного домена приложения будет идентичным имени содержащегося внутри него исполняемого файла (
DefaultAppDomainApp.exeПеречисление загруженных сборок
С применением метода
GetAssemblies()AssemblySystem.ReflectionВ целях иллюстрации определите в классе Program новый вспомогательный метод по имени
ListAllAssembliesInAppDomain()static void ListAllAssembliesInAppDomain(){ // Получить доступ к домену приложения для текущего потока. AppDomain defaultAD = AppDomain.CurrentDomain; // Извлечь все сборки, загруженные в стандартный домен приложения. Assembly[] loadedAssemblies = defaultAD.GetAssemblies(); Console.WriteLine("***** Here are the assemblies loaded in {0} *****\n", defaultAD.FriendlyName); foreach(Assembly a in loadedAssemblies) { // Вывести имя и версию Console.WriteLine($"-> Name, Version: {a.GetName().Name}:{a.GetName().Version}" ); }}Добавив к операторам верхнего уровня вызов метода
ListAllAssembliesInAppDomain()***** Here are the assemblies loaded in DefaultAppDomainApp *****-> Name, Version: System.Private.CoreLib:5.0.0.0-> Name, Version: DefaultAppDomainApp:1.0.0.0-> Name, Version: System.Runtime:5.0.0.0-> Name, Version: System.Console:5.0.0.0-> Name, Version: System.Threading:5.0.0.0-> Name, Version: System.Text.Encoding.Extensions:5.0Важно понимать, что список загруженных сборок может изменяться в любой момент по мере написания нового кода С#. Например, предположим, что метод
ListAllAssembliesInAppDomain()using System.Linq;static void ListAllAssembliesInAppDomain(){ // Получить доступ к домену приложения для текущего потока. AppDomain defaultAD = AppDomain.CurrentDomain; // Извлечь все сборки, загруженные в стандартный домен приложения. var loadedAssemblies = defaultAD.GetAssemblies().OrderBy(x=>x.GetName().Name); Console.WriteLine("***** Here are the assemblies loaded in {0} *****\n", defaultAD.FriendlyName); foreach(Assembly a in loadedAssemblies) { // Вывести имя и версию Console.WriteLine($"-> Name, Version: {a.GetName().Name}:{a.GetName().Version}" ); }}Запустив приложение еще раз, вы заметите, что в память также была загружена сборка
System.Linq.dll** Here are the assemblies loaded in DefaultAppDomainApp **-> Name, Version: DefaultAppDomainApp:1.0.0.0-> Name, Version: System.Console:5.0.0.0-> Name, Version: System.Linq:5.0.0.0-> Name, Version: System.Private.CoreLib:5.0.0.0-> Name, Version: System.Runtime:5.0.0.0-> Name, Version: System.Text.Encoding.Extensions:5.0.0.0-> Name, Version: System.Threading:5.0.0Изоляция сборок с помощью контекстов загрузки приложений
Как вам уже известно, домены приложений представляют собой логические разделы, используемые для обслуживания сборок .NET Core. Кроме того, домен приложения может быть дополнительно разделен на многочисленные границы контекстов загрузки. Концептуально контекст загрузки создает область видимости для загрузки, распознавания и потенциально выгрузки набора сборок. По существу контекст загрузки .NET Core наделяет одиночный домен приложения возможностью установить "конкретный дом" для заданного объекта.
На заметку! Хотя понимать процессы и домены приложений довольно-таки важно, в большинстве приложений .NET Core никогда не потребуется работать с контекстами загрузки. Этот обзорный материал был включен в книгу только ради того, чтобы представить более полную картину.
Класс
AssemblyLoadContextClassLibaryldotnet new classlib -lang c# -n ClassLibrary1 -o .\ClassLibrary1 -f net5.0dotnet sln .\Chapter14_AllProjects.sln add .\ClassLibrary1Затем добавьте в
DefaultAppDomainAppClassLibrary1dotnet add DefaultAppDomainApp reference ClassLibrary1Если вы работаете в Visual Studio, тогда щелкните правой кнопкой мыши на узле решения в окне Solution Explorer, выберите в контекстном меню пункт Add►New Project (Добавить►Новый проект. В результате создается проект
ClassLibrary1DefaultAppDomainApp
Добавьте в новую библиотеку классов класс
Carnamespace ClassLibrary1{ public class Car { public string PetName { get; set; } public string Make { get; set; } public int Speed { get; set; } }}Теперь, имея новую сборку, добавьте необходимые операторы
usingusing System.IO;using System.Runtime.Loader;Метод, добавляемый следующим, требует наличия операторов
usingSystem.IOSystem.Runtime.LoaderProgram.csstatic void LoadAdditionalAssembliesDifferentContexts(){ var path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "ClassLibrary1.dll"); AssemblyLoadContext lc1 = new AssemblyLoadContext("NewContext1",false); var cl1 = lc1.LoadFromAssemblyPath(path); var c1 = cl1.CreateInstance("ClassLibrary1.Car"); AssemblyLoadContext lc2 = new AssemblyLoadContext("NewContext2",false); var cl2 = lc2.LoadFromAssemblyPath(path); var c2 = cl2.CreateInstance("ClassLibrary1.Car"); Console.WriteLine("*** Loading Additional Assemblies in Different Contexts ***"); Console.WriteLine($"Assembly1 Equals(Assembly2) {cl1.Equals(cl2)}"); Console.WriteLine($"Assembly1 == Assembly2 {cl1 == cl2}"); Console.WriteLine($"Class1.Equals(Class2) {c1.Equals(c2)}"); Console.WriteLine($"Class1 == Class2 {c1 == c2}");}В первой строке кода с применением статического метода
Path.Combine()ClassLibrary1На заметку! Вас может интересовать, по какой причине создавалась ссылка на сборку, которая будет загружаться динамически. Это нужно для того, чтобы при компиляции проекта сборка
ClassLibrary1DefaultAppDomainAppДалее в коде создается объект
AssemblyLoadContextNewContext1ClassLibrary1CarAssemblyLoadContextLoadAdditionalAssembliesDifferentContexts()*** Loading Additional Assemblies in Different Contexts ***Assembly1 Equals(Assembly2) FalseAssembly1 == Assembly2 FalseClass1.Equals(Class2) FalseClass1 == Class2 FalseВывод демонстрирует, что та же самая сборка была дважды загружена в домен приложения. Как и следовало ожидать, классы тоже отличаются.
Добавьте новый метод, который будет загружать сборку из того же самого объекта
AssemblyLoadContextstatic void LoadAdditionalAssembliesSameContext(){ var path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "ClassLibrary1.dll"); AssemblyLoadContext lc1 = new AssemblyLoadContext(null,false); var cl1 = lc1.LoadFromAssemblyPath(path); var c1 = cl1.CreateInstance("ClassLibrary1.Car"); var cl2 = lc1.LoadFromAssemblyPath(path); var c2 = cl2.CreateInstance("ClassLibrary1.Car"); Console.WriteLine("*** Loading Additional Assemblies in Same Context ***"); Console.WriteLine($"Assembly1.Equals(Assembly2) {cl1.Equals(cl2)}"); Console.WriteLine($"Assembly1 == Assembly2 {cl1 == cl2}"); Console.WriteLine($"Class1.Equals(Class2) {c1.Equals(c2)}"); Console.WriteLine($"Class1 == Class2 {c1 == c2}");}Главное отличие приведенного выше кода в том, что создается только один объект
AssemblyLoadContextClassLibrary1*** Loading Additional Assemblies in Same Context ***Assembly1.Equals(Assembly2) TrueAssembly1 == Assembly2 TrueClass1.Equals(Class2) FalseClass1 == Class2 FalseИтоговые сведения о процессах, доменах приложений и контекстах загрузки
К настоящему времени вы должны иметь намного лучшее представление о том, как сборка .NET Core обслуживается исполняющей средой. Если изложенный материал показался слишком низкоуровневым, то не переживайте. По большей части .NET Core самостоятельно занимается всеми деталями процессов, доменов приложений и контекстов загрузки. Однако эта информация формирует хороший фундамент для понимания многопоточного программирования на платформе .NET Core.
Резюме
Задачей главы было исследование особенностей обслуживания приложения .NET Core платформой .NET Core. Как вы видели, давно существующее понятие процесса Windows было внутренне изменено и адаптировано под потребности среды CoreCLR. Одиночный процесс (которым можно программно манипулировать посредством типа
System.Diagnostics.ProcessДомен приложения способен размещать и выполнять любое количество связанных сборок. Кроме того, один домен приложения может содержать любое количество контекстов загрузки для дальнейшей изоляции сборок. Благодаря такому дополнительному уровню изоляции типов среда CoreCLR обеспечивает надлежащую обработку объектов с особыми потребностями во время выполнения.
Глава 15 Многопоточное, параллельное и асинхронное программирование
Вряд ли кому-то понравится работать с приложением, которое притормаживает во время выполнения. Аналогично никто не будет в восторге от того, что запуск какой-то задачи внутри приложения (возможно, по щелчку на элементе в панели инструментов) снижает отзывчивость других частей приложения. До выхода платформы .NET (и .NET Core) построение приложений, способных выполнять сразу несколько задач, обычно требовало написания сложного кода на языке C++, в котором использовались API-интерфейсы многопоточности Windows. К счастью, платформы .NET и .NET Core предлагают ряд способов построения программного обеспечения, которое может совершать нетривиальные операции по уникальным путям выполнения, с намного меньшими сложностями.
Глава начинается с определения общей природы "многопоточного приложения". Затем будет представлено первоначальное пространство имен для многопоточности, поставляемое со времен версии .NET 1.0 и называемое
System.ThreadingThreadThreadStartВ оставшихся разделах главы будут рассматриваться три более новых технологии, которые разработчики приложений .NET Core могут применять для построения многопоточного программного обеспечения: библиотека параллельных задач (Task Parallel Library — TPL), технология PLINQ (Parallel LINQ — параллельный LINQ) и появившиеся относительно недавно (в версии C# 6) ключевые слова, связанные с асинхронной обработкой (
asyncawaitОтношения между процессом, доменом приложения, контекстом и потоком
В главе 14 поток определялся как путь выполнения внутри исполняемого приложения. Хотя многие приложения .NET Core могут успешно и продуктивно работать, будучи однопоточными, первичный поток сборки (создаваемый исполняющей средой при выполнении точки входа приложения) в любое время может порождать вторичные потоки для выполнения дополнительных единиц работы. За счет создания дополнительных потоков можно строить более отзывчивые (но не обязательно быстрее выполняющиеся на одноядерных машинах) приложения.
Пространство имен
System.ThreadingThreadThread.CurrentThreadstatic void ExtractExecutingThread(){ // Получить поток, который в настоящий момент выполняет данный метод. Thread currThread = Thread.CurrentThread;}Вспомните, что в .NET Core существует только один домен приложения. Хотя создавать дополнительные домены приложений нельзя, домен приложения может иметь многочисленные потоки, выполняющиеся в каждый конкретный момент времени. Чтобы получить ссылку на домен приложения, который обслуживает приложение, понадобится вызвать статический метод
Thread.GetDomain()static void ExtractAppDomainHostingThread(){ // Получить домен приложения, обслуживающий текущий поток. AppDomain ad = Thread.GetDomain();}Одиночный поток в любой момент также может быть перенесен в контекст выполнения и перемещаться внутри нового контекста выполнения по прихоти среды .NET Core Runtime. Для получения текущего контекста выполнения, в котором выполняется поток, используется статическое свойство
Thread.CurrentThread.ExecutionContextstatic void ExtractCurrentThreadExecutionContext(){ // Получить контекст выполнения, в котором работает текущий поток. ExecutionContext ctx = Thread.CurrentThread.ExecutionContext;}Еще раз: за перемещение потоков в контекст выполнения и из него отвечает среда .NET Core Runtime. Как разработчик приложений .NET Core, вы всегда остаетесь в блаженном неведении относительно того, где завершается каждый конкретный поток. Тем не менее, вы должны быть осведомлены о разнообразных способах получения лежащих в основе примитивов.
Сложность, связанная с параллелизмом
Один из многих болезненных аспектов многопоточного программирования связан с ограниченным контролем над тем, как операционная система или исполняющая среда задействует потоки. Например, написав блок кода, который создает новый поток выполнения, нельзя гарантировать, что этот поток запустится немедленно. Взамен такой код только инструктирует операционную систему или исполняющую среду о необходимости как можно более скорого запуска потока (что обычно происходит, когда планировщик потоков добирается до него).
Кроме того, учитывая, что потоки могут перемещаться между границами приложений и контекстов, как требуется исполняющей среде, вы должны представлять, какие аспекты приложения являются изменчивыми в потоках (например, подвергаются многопоточному доступу), а какие операции считаются атомарными (операции, изменчивые в потоках, опасны).
Чтобы проиллюстрировать проблему, давайте предположим, что поток вызывает метод специфичного объекта. Теперь представим, что поток приостановлен планировщиком потока, чтобы позволить другому потоку обратиться к тому же методу того же самого объекта.
Если исходный поток не завершил свою операцию, тогда второй входящий поток может увидеть объект в частично модифицированном состоянии. В таком случае второй поток по существу читает фиктивные данные, что определенно может привести к очень странным (и трудно обнаруживаемым) ошибкам, которые еще труднее воспроизвести и устранить.
С другой стороны, атомарные операции в многопоточной среде всегда безопасны. К сожалению, в библиотеках базовых классов .NET Core есть лишь несколько гарантированно атомарных операций. Даже действие по присваиванию значения переменной-члену не является атомарным! Если только в документации по .NET Core специально не сказано об атомарности операции, то вы обязаны считать ее изменчивой в потоках и предпринимать соответствующие меры предосторожности.
Роль синхронизации потоков
К настоящему моменту должно быть ясно, что многопоточные программы сами по себе довольно изменчивы, т.к. многочисленные потоки могут оперировать разделяемыми ресурсами (более или менее) одновременно. Чтобы защитить ресурсы приложений от возможного повреждения, разработчики приложений .NET Core должны применять потоковые примитивы (такие как блокировки, мониторы, атрибут
[Synchronization]Несмотря на то что платформа .NET Core не способна полностью скрыть сложности, связанные с построением надежных многопоточных приложений, сам процесс был значительно упрощен. Используя типы из пространства имен
System.ThreadingasyncawaitПрежде чем погрузиться в детали пространства имен
System.ThreadingasyncawaitasyncawaitПространство имен System.Threading
В рамках платформ .NET и .NET Core пространство имен
System.ThreadingSystem.ThreadingTimerВ табл. 15.1 перечислены некоторые важные члены пространства имен
System.Threading
Класс System.Threading.Thread
Класс
ThreadSystem.Threading
Класс
Thread
На заметку! Прекращение работы или приостановка активного потока обычно считается плохой идеей. В таком случае есть шанс (хотя и небольшой), что поток может допустить "утечку" своей рабочей нагрузки.
Получение статистических данных о текущем потоке выполнения
Вспомните, что точка входа исполняемой сборки (т.е. операторы верхнего уровня или метод
Main()ThreadThreadStatsThread.CurrentThreadThread// Не забудьте импортировать пространство имен System.Threading.using System;using System.Threading;Console.WriteLine("***** Primary Thread stats *****\n");// Получить имя текущего потока.Thread primaryThread = Thread.CurrentThread;primaryThread.Name = "ThePrimaryThread";// Вывести статистические данные о текущем потоке.Console.WriteLine("ID of current thread: {0}", primaryThread.ManagedThreadId); // Идентификатор текущего потокаConsole.WriteLine("Thread Name: {0}", primaryThread.Name); // Имя потокаConsole.WriteLine("Has thread started?: {0}", primaryThread.IsAlive); // Запущен ли потокConsole.WriteLine("Priority Level: {0}", primaryThread.Priority); // Приоритет потокаConsole.WriteLine("Thread State: {0}", primaryThread.ThreadState); // Состояние потокаConsole.ReadLine();Вот как выглядит вывод:
***** Primary Thread stats *****ID of current thread: 1Thread Name: ThePrimaryThreadHas thread started?: TruePriority Level: NormalThread State: RunningСвойство Name
Обратите внимание, что класс
ThreadNameNameThread
Свойство Priority
Далее обратите внимание, что в типе
ThreadPriorityNormalPrioritySystem.Threading.ThreadPrioritypublic enum ThreadPriority{ Lowest, BelowNormal, Normal, // Стандартное значение. AboveNormal, Highest}В случае присваивания уровню приоритета потока значения, отличающегося от стандартного(
ThreadPriority.NormalThreadPriority.HighestОпять-таки, если планировщик потоков занят решением определенной задачи (например, синхронизацией объекта, переключением потоков либо их перемещением), то уровень приоритета, скорее всего, будет соответствующим образом изменен. Однако при прочих равных условиях среда .NET Core Runtime прочитает эти значения и проинструктирует планировщик потоков о том, как лучше выделять кванты времени. Потоки с идентичными уровнями приоритета должны получать одинаковое количество времени на выполнение своей работы.
В большинстве случаев необходимость в прямом изменении уровня приоритета потока возникает редко (если вообще возникает). Теоретически можно так повысить уровень приоритета набора потоков, что в итоге воспрепятствовать выполнению низкоприоритетных потоков с их запрошенными уровнями (поэтому соблюдайте осторожность).
Ручное создание вторичных потоков
Когда вы хотите программно создать дополнительные потоки для выполнения какой-то единицы работы, то во время применения типов из пространства имен
System.Threading1. Создать метод, который будет служить точкой входа для нового потока.
2. Создать новый делегат
ParametrizedThreadStartThreadStart3. Создать объект
ThreadParametrizedThreadStart/Threadstart4. Установить начальные характеристики потока (имя, приоритет и т.д.).
5. Вызвать метод
Thread.Start()Согласно шагу 2 для указания на метод, который будет выполняться во вторичном потоке, можно использовать два разных типа делегата. Делегат
ThreadStartОграничение
ThreadStartParametrizedThreadStartSystem.ObjectSystem.ObjectThreadStartParametrizedThreadStartvoidРабота с делегатом ThreadStart
Чтобы проиллюстрировать процесс построения многопоточного приложения (а также его полезность), создайте проект консольного приложения по имени
SimpleMultiThreadAppПосле импортирования пространства имен
System.ThreadingPrinterusing System;using System.Threading;namespace SimpleMultiThreadApp{ public class Printer { public void PrintNumbers() { // Вывести информацию о потоке. Console.WriteLine("-> {0} is executing PrintNumbers()", Thread.CurrentThread.Name); // Вывести числа. Console.Write("Your numbers: "); for(int i = 0; i < 10; i++) { Console.Write("{0}, ", i); Thread.Sleep(2000); } Console.WriteLine(); } }}Добавьте в файл
Program.csPrintNumbers()ThreadStartPrintNumbers()ThreadStart()using System;using System.Threading;using SimpleMultiThreadApp;Console.WriteLine("***** The Amazing Thread App *****\n");Console.Write("Do you want [1] or [2] threads? ");string threadCount = Console.ReadLine(); // Запрос количества потоков// Назначить имя текущему потоку.Thread primaryThread = Thread.CurrentThread;primaryThread.Name = "Primary";// Вывести информацию о потоке.Console.WriteLine("-> {0} is executing Main()",Thread.CurrentThread.Name);// Создать рабочий класс.Printer p = new Printer();switch(threadCount){ case "2": // Создать поток. Thread backgroundThread = new Thread(new ThreadStart(p.PrintNumbers)); backgroundThread.Name = "Secondary"; backgroundThread.Start(); break; case "1": p.PrintNumbers(); break; default: Console.WriteLine("I don't know what you want...you get 1 thread."); goto case "1"; // Переход к варианту с одним потоком}// Выполнить некоторую дополнительную работу.Console.WriteLine("This is on the main thread, and we are finished.");Console.ReadLine();Если теперь вы запустите программу с одним потоком, то обнаружите, что финальное окно сообщения не будет отображать сообщение, пока вся последовательность чисел не выведется на консоль. Поскольку после вывода каждого числа установлена пауза около 2 секунд, это создаст не особенно приятное впечатление у конечного пользователя. Однако в случае выбора двух потоков окно сообщения отображается немедленно, потому что для вывода чисел на консоль выделен отдельный объект
ThreadРабота с делегатом ParametrizedThreadStart
Вспомните, что делегат
ThreadStartvoidParametrizedThreadStartAddWithThreadsSystem.ThreadingParametrizedThreadStartSystem.Objectnamespace AddWithThreads{ class AddParams { public int a, b; public AddParams(int numb1, int numb2) { a = numb1; b = numb2; } }}Далее создайте в классе
ProgramAddParamsvoid Add(object data){ if (data is AddParams ap) { Console.WriteLine("ID of thread in Add(): {0}", Thread.CurrentThread.ManagedThreadId); Console.WriteLine("{0} + {1} is {2}", ap.a, ap.b, ap.a + ap.b); }}Код в файле
Program.csThreadStartParametrizedThreadStartusing System;using System.Threading;using AddWithThreads;Console.WriteLine("***** Adding with Thread objects *****");Console.WriteLine("ID of thread in Main(): {0}", Thread.CurrentThread.ManagedThreadId);// Создать объект AddParams для передачи вторичному потоку.AddParams ap = new AddParams(10, 10);Thread t = new Thread(new ParameterizedThreadStart(Add));t.Start(ap);// Подождать, пока другой поток завершится.Thread.Sleep(5);Console.ReadLine();Класс AutoResetEvent
В приведенных выше начальных примерах нет какого-либо надежного способа узнать, когда вторичный поток завершит свою работу. В последнем примере метод
Sleep()AutoResetEventAutoResetEventfalseWaitOne()ProgramAutoResetEventAutoResetEvent _waitHandle = new AutoResetEvent(false);Console.WriteLine("***** Adding with Thread objects *****");Console.WriteLine("ID of thread in Main(): {0}", Thread.CurrentThread.ManagedThreadId);AddParams ap = new AddParams(10, 10);Thread t = new Thread(new ParameterizedThreadStart(Add));t.Start(ap);// Ожидать, пока не поступит уведомление!_waitHandle.WaitOne();Console.WriteLine("Other thread is done!");Console.ReadLine();...Когда другой поток завершит свою работу, он вызовет метод
Set()AutoResetEventvoid Add(object data){ if (data is AddParams ap) { Console.WriteLine("ID of thread in Add(): {0}", Thread.CurrentThread.ManagedThreadId); Console.WriteLine("{0} + {1} is {2}", ap.a, ap.b, ap.a + ap.b); // Сообщить другому потоку о том, что работа завершена. _waitHandle.Set(); }}Потоки переднего плана и фоновые потоки
Теперь, когда вы знаете, как программно создавать новые потоки выполнения с применением типов из пространства имен
System.Threading• Потоки переднего плана имеют возможность предохранять текущее приложение от завершения. Среда .NET Core Runtime не будет прекращать работу приложения (скажем, выгружая обслуживающий домен приложения) до тех пор, пока не будут завершены все потоки переднего плана.
• Фоновые потоки (иногда называемые потоками-демонами) воспринимаются средой .NET Core Runtime как расширяемые пути выполнения, которые в любой момент времени могут быть проигнорированы (даже если они заняты выполнением некоторой части работы). Таким образом, если при выгрузке домена приложения все потоки переднего плана завершены, то все фоновые потоки автоматически уничтожаются.
Важно отметить, что потоки переднего плана и фоновые потоки — не синонимы первичных и рабочих потоков. По умолчанию каждый поток, создаваемый посредством метода
Thread.Start()Ради доказательства сделанных утверждений предположим, что метод
Printer.PrintNumbers()ThreadThreadStartParametrizedThreadStartIsBackgroundtrueConsole.WriteLine("***** Background Threads *****\n");Printer p = new Printer();Thread bgroundThread = new Thread(new ThreadStart(p.PrintNumbers));// Теперь это фоновый поток.bgroundThread.IsBackground = true;bgroundThread.Start();Обратите внимание, что в приведенном выше коде не делается вызов
Console.ReadLine()ThreadMain()Однако если закомментировать строку, которая устанавливает свойство
IsBackgroundtrueПо большей части конфигурировать поток для функционирования в фоновом режиме может быть удобно, когда интересующий рабочий поток выполняет некритичную задачу, потребность в которой исчезает после завершения главной задачи программы. Например, можно было бы построить приложение, которое проверяет почтовый сервер каждые несколько минут на предмет поступления новых сообщений электронной почты, обновляет текущий прогноз погоды или решает какие-то другие некритичные задачи.
Проблема параллелизма
При построении многопоточных приложений необходимо гарантировать, что любой фрагмент разделяемых данных защищен от возможности изменения со стороны сразу нескольких потоков. Поскольку все потоки в домене приложения имеют параллельный доступ к разделяемым данным приложения, вообразите, что может произойти, если множество потоков одновременно обратятся к одному и тому же элементу данных. Так как планировщик потоков случайным образом приостанавливает их работу, что если поток
АВЧтобы проиллюстрировать проблему, связанную с параллелизмом, давайте создадим еще один проект консольного приложения под названием
MultiThreadedPrintingPrinterPrintNumbers()using System;using System.Threading;namespace MultiThreadedPrinting{ public class Printer { public void PrintNumbers() { // Отобразить информацию о потоке. Console.WriteLine("-> {0} is executing PrintNumbers()", Thread.CurrentThread.Name); // Вывести числа. for (int i = 0; i < 10; i++) { // Приостановить поток на случайный период времени. Random r = new Random(); Thread.Sleep(1000 * r.Next(5)); Console.Write("{0}, ", i); } Console.WriteLine(); } }}Вызывающий код отвечает за создание массива из десяти (уникально именованных) объектов
ThreadPrinterusing System;using System.Threading;using MultiThreadedPrinting;Console.WriteLine("*****Synchronizing Threads *****\n");Printer p = new Printer();// Создать 10 потоков, которые указывают на один.// и тот же метод того же самого объектаThread[] threads = new Thread[10];for (int i = 0; i < 10; i++){ threads[i] = new Thread(new ThreadStart(p.PrintNumbers)) { Name = $"Worker thread #{i}" };}// Теперь запустить их все.foreach (Thread t in threads){ t.Start();}Console.ReadLine();Прежде чем взглянуть на тестовые запуски, кратко повторим суть проблемы. Первичный поток внутри этого домена приложения начинает свое существование с порождения десяти вторичных рабочих потоков. Каждому рабочему потоку указывается на необходимость вызова метода
PrintNumbers()PrinterPrintNumbers()*****Synchronizing Threads *****-> Worker thread #3 is executing PrintNumbers()-> Worker thread #0 is executing PrintNumbers()-> Worker thread #1 is executing PrintNumbers()-> Worker thread #2 is executing PrintNumbers()-> Worker thread #4 is executing PrintNumbers()-> Worker thread #5 is executing PrintNumbers()-> Worker thread #6 is executing PrintNumbers()-> Worker thread #7 is executing PrintNumbers()-> Worker thread #8 is executing PrintNumbers()-> Worker thread #9 is executing PrintNumbers()0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 1, 2, 3, 1, 2, 2, 2, 1, 2,1, 1, 2, 2, 3, 3, 4, 3, 3, 2, 2, 3, 4, 3, 4, 5, 4, 5, 4, 4, 3, 6, 7, 2, 3, 4, 4, 4, 5, 6, 5,3, 5, 8, 9,6, 7, 4, 5, 6, 6, 5, 5, 5, 8, 5, 6, 7, 8, 7, 7, 6, 6, 6, 8, 9,8, 7, 7, 7, 7, 9,6, 8, 9,8, 9,9, 9,8, 8, 7, 8, 9,9,9,Запустите приложение еще несколько раз. Скорее всего, каждый раз вы будете получать отличающийся вывод.
На заметку! Если получить непредсказуемый вывод не удается, увеличьте количество потоков с 10 до 100 (например) или добавьте в код еще один вызов
Thread.Sleep()Должно быть совершенно ясно, что здесь присутствуют проблемы. В то время как каждый поток сообщает экземпляру
PrinterSystem.ThreadingСинхронизация с использованием ключевого слова lock языка C#
Первый прием, который можно применять для синхронизации доступа к разделяемым ресурсам, предполагает использование ключевого слова
locklockprivate void SomePrivateMethod(){ // Использовать текущий объект как маркер потока. lock(this) { // Весь код внутри этого блока является безопасным к потокам. }}Тем не менее, если блокируется область кода внутри открытого члена, то безопаснее (да и рекомендуется) объявить закрытую переменную-член типа
objectpublic class Printer{ // Маркер блокировки. private object threadLock = new object(); public void PrintNumbers() { // Использовать маркер блокировки. lock (threadLock) { ... } }}В любом случае, если взглянуть на метод
PrintNumbers()Consolelockpublic void PrintNumbers(){ // Использовать в качестве маркера блокировки закрытый член object. lock (threadLock) { // Вывести информацию о потоке. Console.WriteLine("-> {0} is executing PrintNumbers()", Thread.CurrentThread.Name); // Вывести числа. Console.Write("Your numbers: "); for (int i = 0; i < 10; i++) { Random r = new Random(); Thread.Sleep(1000 * r.Next(5)); Console.Write("{0}, ", i); } Console.WriteLine(); }}В итоге вы построили метод, который позволит текущему потоку завершить свою задачу. Как только поток входит в область
locklockААНа заметку! Если необходимо блокировать код в статическом методе, тогда следует просто объявить закрытую статическую переменную-член типа
objectЗапустив приложение, вы заметите, что каждый поток получил возможность выполнить свою работу до конца:
*****Synchronizing Threads *****-> Worker thread #0 is executing PrintNumbers()Your numbers: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,-> Worker thread #1 is executing PrintNumbers()Your numbers: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,-> Worker thread #3 is executing PrintNumbers()Your numbers: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,-> Worker thread #2 is executing PrintNumbers()Your numbers: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,-> Worker thread #4 is executing PrintNumbers()Your numbers: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,-> Worker thread #5 is executing PrintNumbers()Your numbers: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,-> Worker thread #7 is executing PrintNumbers()Your numbers: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,-> Worker thread #6 is executing PrintNumbers()Your numbers: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,-> Worker thread #8 is executing PrintNumbers()Your numbers: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,-> Worker thread #9 is executing PrintNumbers()Your numbers: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,Синхронизация с использованием типа System.Threading.Monitor
Оператор
lockSystem.Threading.Monitorlockldasm.exepublic void PrintNumbers(){ Monitor.Enter(threadLock); try { // Вывести информацию о потоке. Console.WriteLine("-> {0} is executing PrintNumbers()", Thread.CurrentThread.Name); // Вывести числа. Console.Write("Your numbers: "); for (int i = 0; i < 10; i++) { Random r = new Random(); Thread.Sleep(1000 * r.Next(5)); Console.Write("{0}, ", i); } Console.WriteLine(); } finally { Monitor.Exit(threadLock); }}Первым делом обратите внимание, что конечным получателем маркера потока, который указывается как аргумент ключевого слова
lockMonitor. Enter()locktryfinallyMonitor.Exit()MultiThreadShareDataMonitorС учетом того, что ключевое слово
lockSystem.Threading.MonitorMonitorMonitorMonitor.Wait()Monitor.Pulse()Monitor.PulseAll()Как и можно было ожидать, в значительном числе случаев ключевого слова
lockMonitorСинхронизация с использованием типа System.Threading.Interlocked
Не заглядывая в код CIL, обычно нелегко поверить в то, что присваивание и простые арифметические операции не являются атомарными. По указанной причине в пространстве имен
System.ThreadingMonitorInterlocked
Несмотря на то что это не сразу видно, процесс атомарного изменения одиночного значения довольно часто применяется в многопоточной среде. Пусть имеется код, который инкрементирует целочисленную переменную-член по имени
intValint intVal = 5;object myLockToken = new();lock(myLockToken){ intVal++;}код можно упростить, используя статический метод
Interlocked.Increment()Методу потребуется передать инкрементируемую переменную по ссылке. Обратите внимание, что метод
Increment()intVal = Interlocked.Increment(ref intVal);В дополнение к методам
Increment()Decrement()Interlocked83lockMonitorInterlock.Exchange()Interlocked.Exchange(ref myInt, 83);Наконец, если необходимо проверить два значения на предмет равенства и изменить элемент сравнения в безопасной к потокам манере, тогда допускается использовать метод
Interlocked.CompareExchange()public void CompareAndExchange(){ // Если значение i равно 83, то изменить его на 99. Interlocked.CompareExchange(ref i, 99, 83);}Программирование с использованием обратных вызовов Timer
Многие приложения нуждаются в вызове специфического метода через регулярные интервалы времени. Например, в приложении может существовать необходимость в отображении текущего времени внутри панели состояния с помощью определенной вспомогательной функции. Или, скажем, нужно, чтобы приложение эпизодически вызывало вспомогательную функцию, выполняющую некритичные фоновые задачи, такие как проверка поступления новых сообщений электронной почты. В ситуациях подобного рода можно применять тип
System.Threading.TimerTimerCallbackВ целях иллюстрации предположим, что у вас есть проект консольного приложения (
TimerAppTimerSystem.Threadingusing System;using System.Threading;Console.WriteLine("***** Working with Timer type *****\n");Console.ReadLine();static void PrintTime(object state){ Console.WriteLine("Time is: {0}", DateTime.Now.ToLongTimeString());}Обратите внимание, что метод
PrintTime()System.ObjectvoidTimerCallbackTimerCallbackSystem.ObjectSystem.ArrayСледующий шаг связан с конфигурированием экземпляра делегата
TimerCallbackTimerTimerCallbackTimerSystem.ObjectConsole.WriteLine("***** Working with Timer type *****\n");// Создать делегат для типа Timer.TimerCallback timeCB = new TimerCallback(PrintTime);// Установить параметры таймера.Timer t = new Timer( timeCB, // Объект делегата TimerCallback. null, // Информация для передачи в вызванный метод. // (null, если информация отсутствует). 0, // Период ожидания перед запуском (в миллисекундах). 1000); // Интервал между вызовами (в миллисекундах).Console.WriteLine("Hit Enter key to terminate...");Console.ReadLine();В этом случае метод
PrintTime()***** Working with Timer type *****Hit key to terminate...Time is: 6:51:48 PMTime is: 6:51:49 PMTime is: 6:51:50 PMTime is: 6:51:51 PMTime is: 6:51:52 PMPress any key to continue ...Чтобы передать целевому методу делегата какую-то информацию, необходимо просто заменить значение
null// Установить параметры таймера.Timer t = new Timer(timeCB, "Hello From C# 9.0", 0, 1000);You can then obtain the incoming data as follows:static void PrintTime(object state){ Console.WriteLine("Time is: {0}, Param is: {1}", DateTime.Now.ToLongTimeString(), state.ToString());}Использование автономного отбрасывания (нововведение в версии 7.0)
В предыдущем примере переменная
Timer var _ = new Timer( timeCB, // Объект делегата TimerCallback. null, // Информация для передачи в вызванный метод // (null, если информация отсутствует). 0, // Период ожидания перед запуском // (в миллисекундах). 1000); // Интервал между вызовами // (в миллисекундах). Класс ThreadPool
Следующей темой о потоках, которую мы рассмотрим в настоящей главе, будет роль пула потоков. Запуск нового потока связан с затратами, поэтому в целях повышения эффективности пул потоков удерживает созданные (но неактивные) потоки до тех пор, пока они не понадобятся. Для взаимодействия с этим пулом ожидающих потоков в пространстве имен
System.ThreadingThreadPoolЧтобы запросить поток из пула для обработки вызова метода, можно использовать метод
ThreadPool.QueueUserWorkItem()WaitCallbackSystem.Objectpublic static class ThreadPool{ ... public static bool QueueUserWorkItem(WaitCallback callBack); public static bool QueueUserWorkItem(WaitCallback callBack, object state);}Делегат
WaitCallbackSystem.ObjectQueueUserWorkItem()System.ObjectnullThreadPoolAppPrinterThreadPrintNumbers()using System;using System.Threading;using ThreadPoolApp;Console.WriteLine("***** Fun with the .NET Core Runtime Thread Pool *****\n");Console.WriteLine("Main thread started. ThreadID = {0}", Thread.CurrentThread.ManagedThreadId);Printer p = new Printer();WaitCallback workItem = new WaitCallback(PrintTheNumbers);// Поставить в очередь метод десять раз.for (int i = 0; i < 10; i++){ ThreadPool.QueueUserWorkItem(workItem, p);}Console.WriteLine("All tasks queued");Console.ReadLine();static void PrintTheNumbers(object state){ Printer task = (Printer)state; task.PrintNumbers();}У вас может возникнуть вопрос: почему взаимодействовать с пулом потоков, поддерживаемым средой .NET Core Runtime, выгоднее по сравнению с явным созданием объектов
Thread• Пул потоков эффективно управляет потоками, сводя к минимуму количество потоков, которые должны создаваться, запускаться и останавливаться.
• За счет применения пула потоков можно сосредоточиться на решении задачи, а не на потоковой инфраструктуре приложения.
Тем не менее, в некоторых случаях ручное управление потоками оказывается более предпочтительным. Ниже приведены примеры.
• Когда требуются потоки переднего плана или должен устанавливаться приоритет потока. Потоки из пула всегда являются фоновыми и обладают стандартным приоритетом (
ThreadPriority.Normal• Когда требуется поток с фиксированной идентичностью, чтобы его можно было прерывать, приостанавливать или находить по имени.
На этом исследование пространства имен
System.ThreadingПараллельное программирование с использованием TPL
Вы уже ознакомились с объектами из пространства имен
System.ThreadingSystem.Threading.TasksОднако речь не идет о том, что вы не будете использовать типы из пространства имен
System.ThreadingSystem.ThreadingMonitorInterlockedSystem.ThreadingПространство имен System.Threading.Tasks
Все вместе типы из пространства
System.Threading.TasksРоль класса Parallel
Основным классом в TPL является
System.Threading.Tasks.ParallelIEnumerableParallel.For()Parallel.ForEach()Упомянутые методы позволяют создавать тело из операторов кода, которое будет выполняться в параллельном режиме. Концептуально такие операторы представляют логику того же рода, которая была бы написана в нормальной циклической конструкции (с использованием ключевых слов
forforeachParallelОба метода требуют передачи совместимого с
IEnumerableIEnumerableArrayListListВдобавок понадобится применять делегаты
System.FuncSystem.ActionFuncFuncActionFuncvoidХотя можно было бы вызывать методы
Parallel.For()Parallel.ForEach()FuncActionОбеспечение параллелизма данных с помощью класса Parallel
Первое применение библиотеки TPL связано с обеспечением параллелизма данных. Таким термином обозначается задача прохода по массиву или коллекции в параллельной манере с помощью метода
Parallel.For()Parallel.ForEach()*.jpgЗадача будет решаться с использованием графического пользовательского интерфейса, так что вы увидите, как применять "анонимные делегаты", позволяющие вторичным потокам обновлять первичный поток пользовательского интерфейса.
На заметку! При построении многопоточного приложения с графическим пользовательским интерфейсом вторичные потоки никогда не смогут напрямую обращаться к элементам управления пользовательского интерфейса. Причина в том, что элементы управления (кнопки, текстовые поля, метки, индикаторы хода работ и т.п.) привязаны к потоку, в котором они создавались. В следующем примере иллюстрируется один из способов обеспечения для вторичных потоков возможности получать доступ к элементам пользовательского интерфейса в безопасной к потокам манере. Во время рассмотрения ключевых слов
asyncawaitВ целях иллюстрации создайте приложение Windows Presentation Foundation (WPF) по имени
DataParallelismWithForEachdotnet new wpf -lang c# -n DataParallelismWithForEach -o .\DataParallelismWithForEach -f net5.0dotnet sln .\Chapter15_AllProjects.sln add .\DataParallelismWithForEachНа заметку! Инфраструктура Windows Presentation Foundation (WPF) в текущей версии .NET Core предназначена только для Windows и будет подробно рассматриваться в главах 24-28. Если вы еще не работали с WPF, то здесь описано все, что необходимо для данного примера. Разработка приложений WPF ведется в среде Visual Studio Code, хотя никаких визуальных конструкторов там не предусмотрено. Чтобы получить больший опыт разработки приложений WPF, рекомендуется использовать Visual Studio 2019.
Дважды щелкните на имени файла
MainWindow.xaml xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:d="http://schemas.microsoft.com/expression/blend/2008" xmlns:local="clr-namespace:DataParallelismWithForEach" mc:Ignorable="d" Title="Fun with TPL" Height="400" Width="800"> Feel free to type here while the images are processed... Margin="10,10,0,10" Click="cmdCancel_Click"> Cancel Margin="0,10,10,10" Click="cmdProcess_Click"> Click to Flip Your Images! И снова пока не следует задаваться вопросом о том, что означает приведенная разметка или как она работает; вскоре вам придется посвятить немало времени на исследование WPF. Графический пользовательский интерфейс приложения состоит из многострочной текстовой области
TextBoxButtoncmdProcessВ этом примере требуется дополнительный пакет NuGet (
System.Drawing.Commondotnet add DataParallelismWithForEach package System.Drawing.CommonДважды щелкнув на имени файла
MainWindow.xaml.csMainWindow.xamlusing// Обеспечить доступ к перечисленным ниже пространствам имен!// (System.Threading.Tasks уже должно присутствовать благодаря// выбранному шаблону.)using System;using System.Drawing;using System.Threading.Tasks;using System.Threading;using System.Windows;using System.IO;На заметку! Вы должны обновить строку, передаваемую методу
Directory.GetFiles()TestPicturespublic partial class MainWindow : Window{ public MainWindow() { InitializeComponent(); } private void cmdCancel_Click(object sender, EventArgs e) { // Код метода будет вскоре обновлен. } private void cmdProcess_Click(object sender, EventArgs e) { ProcessFiles(); this.Title = "Processing Complete"; } private void ProcessFiles() { // Загрузить все файлы *.jpg и создать новый каталог // для модифицированных данных. // Получить путь к каталогу с исполняемым файлом. // В режиме отладки VS 2019 текущим каталогом будет // <каталог npoeктa>\bin\debug\net5.0 - windows. // В случае VS Code или команды dotnet run текущим // каталогом будет <каталог проекта>. var basePath = Directory.GetCurrentDirectory(); var pictureDirectory = Path.Combine(basePath, "TestPictures"); var outputDirectory = Path.Combine(basePath, "ModifiedPictures"); // Удались любые существующие файлы. if (Directory.Exists(outputDirectory)) { Directory.Delete(outputDirectory, true); } Directory.CreateDirectory(outputDirectory); string[] files = Directory.GetFiles(pictureDirectory, "*.jpg", SearchOption.AllDirectories); // Обработать данные изображений в блокирующей манере. foreach (string currentFile in files) { string filename = System.IO.Path.GetFileName(currentFile); // Вывести идентификатор потока, обрабатывающего текущее изображение. this.Title = $"Processing {filename} on thread {Thread.CurrentThread.ManagedThreadId}"; using (Bitmap bitmap = new Bitmap(currentFile)) { bitmap.RotateFlip(RotateFlipType.Rotate180FlipNone); bitmap.Save(System.IO.Path.Combine( outputDirectory, filename)); } } }}На заметку! В случае получения сообщения об ошибке, связанной с неоднозначностью имени
PathSystem.IO.PathSystem.Windows.Shapes.PathusingSystem.Windows.ShapesSystem.IOPathSystem.IO.Path.Combine(...).Обратите внимание, что метод
ProcessFiles()*.jpgЧтобы обрабатывать файлы на как можно большем количестве процессоров, текущий цикл
foreachParallel.ForEach()IEnumerablefilesActionНиже приведен модифицированный код, где вместо литерального объекта делегата
Action// Обработать данные изображений в параллельном режиме!Parallel.ForEach(files, currentFile => { string filename = Path.GetFileName(currentFile); // Этот оператор теперь приводит к проблеме! См. следующий раздел. // this.Title = $" Processing {filename} on thread // {Thread.CurrentThread.ManagedThreadld}" // Thread.CurrentThread.ManagedThreadld); using (Bitmap bitmap = new Bitmap( currentFile)) using (Bitmap bitmap = new Bitmap(currentFile)) { bitmap.RotateFlip(RotateFlipType.Rotate180FlipNone); bitmap.Save(Path.Combine(outputDirectory, filename)); } });Доступ к элементам пользовательского интерфейса во вторичных потоках
Вы наверняка заметили, что в показанном выше коде закомментированы строки, которые обновляют заголовок главного окна значением идентификатора текущего выполняющегося потока. Как упоминалось ранее, элементы управления графического пользовательского интерфейса привязаны к потоку, где они были созданы. Если вторичные потоки пытаются получить доступ к элементу управления, который они напрямую не создавали, то при отладке программного обеспечения возникают ошибки времени выполнения. С другой стороны, если запустить приложение (нажатием <Ctrl+F5>), тогда первоначальный код может и не вызвать каких-либо проблем.
На заметку! Не лишним будет повторить: при отладке многопоточного приложения вы иногда будете получать ошибки, когда вторичный поток обращается к элементу управления, созданному в первичном потоке. Однако часто после запуска приложение может выглядеть функционирующим корректно (или же довольно скоро может возникнуть ошибка). Если не предпринять меры предосторожности (описанные далее), то приложение в подобных обстоятельствах может потенциально сгенерировать ошибку во время выполнения.
Один из подходов, который можно использовать для предоставления вторичным потокам доступа к элементам управления в безопасной к потокам манере, предусматривает применение другого приема — анонимного делегата. Родительский класс
ControlDispatcherInvoke()System.Delegate// Этот код больше не работает!// this.Title = $"Processing {filename} on thread {Thread.// CurrentThread.ManagedThreadld}";// Вызвать Invoke() на объекте Dispatcher, чтобы позволить вторичным потокам// получать доступ к элементам управления в безопасной к потокам манере.Dispatcher?.Invoke(() =>{ this.Title = $"Processing {filename}";});using (Bitmap bitmap = new Bitmap(currentFile)){ bitmap.RotateFlip(RotateFlipType.Rotate180FlipNone); bitmap.Save(Path.Combine(outputDirectory, filename));}Теперь после запуска программы библиотека TPL распределит рабочую нагрузку по множеству потоков из пула, используя столько процессоров, сколько возможно. Тем не менее, поскольку заголовок
TitleTitleКласс Task
Класс
TaskClickButtonprivate void cmdProcess_Click(object sender, EventArgs e){ // Запустить новую "задачу" для обработки файлов. Task.Factory.StartNew(() => ProcessFiles()); // Можно записать и так: // Task.Factory.StartNew(ProcessFiles);}Свойство
FactoryTaskTaskFactoryStartNew()ActionОбработка запроса на отмену
В текущий пример можно внести еще одно улучшение — предоставить пользователю способ для останова обработки данных изображений путем щелчка на второй кнопке Cancel (Отмена). К счастью, методы
Parallel.For()Parallel.ForEach()ParallelParallelOptionsCancellationTokenSourceПервым делом определите в производном от Window классе закрытую переменную-член
_cancelTokenCancellationTokenSourcepublic partial class MainWindow :Window{ // Новая переменная уровня Window. private CancellationTokenSource _cancelToken = new CancellationTokenSource(); ...}Обновите обработчик события
Clickprivate void cmdCancel_Click(object sender, EventArgs e){ // Используется для сообщения всем рабочим потокам о необходимости останова! _cancelToken.Cancel();}Теперь можно заняться необходимыми модификациями метода
ProcessFiles()private void ProcessFiles(){ // Использовать экземпляр ParallelOptions для хранения CancellationToken. ParallelOptions parOpts = new ParallelOptions(); parOpts.CancellationToken = _cancelToken.Token; parOpts.MaxDegreeOfParallelism = System.Environment.ProcessorCount; // Загрузить все файлы *.jpg и создать новый каталог // для модифицированных данных. string[] files = Directory.GetFiles(@".\TestPictures", "*.jpg", SearchOption.AllDirectories); string outputDirectory = @".\ModifiedPictures"; Directory.CreateDirectory(outputDirectory); try { // Обработать данные изображения в параллельном режиме! Parallel.ForEach(files, parOpts, currentFile => { parOpts .CancellationToken.ThrowIfCancellationRequested(); string filename = Path.GetFileName(currentFile); Dispatcher?.Invoke(() => { this.Title = $"Processing {filename} on thread {Thread.CurrentThread.ManagedThreadId}"; }); using (Bitmap bitmap = new Bitmap(currentFile)) { bitmap.RotateFlip(RotateFlipType.Rotate180FlipNone); bitmap.Save(Path.Combine(outputDirectory, filename)); } }); Dispatcher?.Invoke(()=>this.Title = "Done!"); } catch (OperationCanceledException ex) { Dispatcher?.Invoke(()=>this.Title = ex.Message); }}Обратите внимание, что в начале метода конфигурируется объект
ParallelOptionsCancellationTokenCancellationTokenSourceParallelOptionsParallel.ForEach()Внутри логики цикла осуществляется вызов
ThrowIfCancellationRequested()OperationCanceledExceptionОбеспечение параллелизма задач с помощью класса Parallel
В дополнение к обеспечению параллелизма данных библиотека TPL также может использоваться для запуска любого количества асинхронных задач с помощью метода
Parallel.Invoke()System.ThreadingParallel.Invoke()TaskЧтобы взглянуть на параллелизм задач в действии, создайте новый проект консольного приложения по имени
MyEBookReaderProgram.csSystem.ThreadingSystem.TextSystem.Threading.TasksSystem.LinqSystem.Netwww.gutenberg.orgGetBook()using System;using System.Linq;using System.Threading;using System.Threading.Tasks;using System.Net;using System.Text;string _theEBook = "";GetBook();Console.WriteLine("Downloading book...");Console.ReadLine();void GetBook(){ WebClient wc = new WebClient(); wc.DownloadStringCompleted += (s, eArgs) => { _theEBook = eArgs.Result; Console.WriteLine("Download complete."); GetStats(); }; // Загрузить электронную книгу Чарльза Диккенса "A Tale of Two Cities". // Может понадобиться двукратное выполнение этого кода, если ранее вы // не посещали данный сайт, поскольку при первом его посещении появляется // окно с сообщением, предотвращающее нормальное выполнение кода. wc.DownloadStringAsync(new Uri("http://www.gutenberg.org/ files/98/98-8.txt"));}Класс
WebClientSystem.NetDownloadStringAsync()WebClientDownloadStringCompletedDownloadString()Downloading book...Далее реализуйте метод
GetStats()theEBookvoid GetStats(){ // Получить слова из электронной книги. string[] words = _theEBook.Split(new char[] { ' ', '\u000A', ',', '.', ';', ':', '-', '?', '/' }, StringSplitOptions.RemoveEmptyEntries); // Найти 10 наиболее часто встречающихся слов. string[] tenMostCommon = FindTenMostCommon(words); // Получить самое длинное слово. string longestWord = FindLongestWord(words); // Когда все задачи завершены, построить строку, показывающую // все статистические данные в окне сообщений. StringBuilder bookStats = new StringBuilder("Ten Most Common Words are:\n"); foreach (string s in tenMostCommon) { bookStats.AppendLine(s); } bookStats.AppendFormat("Longest word is: {0}", longestWord); // Самое длинное слово bookStats.AppendLine(); Console.WriteLine(bookStats.ToString(), "Book info"); // Информация о книге}Метод
FindTenMostCommon()stringstringFindLongestWord()string[] FindTenMostCommon(string[] words){ var frequencyOrder = from word in words where word.Length > 6 group word by word into g orderby g.Count() descending select g.Key; string[] commonWords = (frequencyOrder.Take(10)).ToArray(); return commonWords;}string FindLongestWord(string[] words){ return (from w in words orderby w.Length descending select w) .FirstOrDefault();}После запуска проекта выполнение всех задач может занять внушительный промежуток времени, что зависит от количества процессоров в машине и их тактовой частоты. В конце концов, должен появиться следующий вывод:
Downloading book...Download complete.Ten Most Common Words are:DefargehimselfManettethroughnothingbusinessanotherlookingprisonerCruncherLongest word is: undistinguishableПомочь удостовериться в том, что приложение задействует все доступные процессоры машины, может параллельный вызов методов
FindTenMostCommon()FindLongestWord()GetStats():void GetStats(){ // Получить слова из электронной книги. string[] words = _theEBook.Split( new char[] { ' ', '\u000A', ',', '.', ';', ':', '-', '?', '/' }, StringSplitOptions.RemoveEmptyEntries); string[] tenMostCommon = null; string longestWord = string.Empty; Parallel.Invoke( () => { // Найти 10 наиболее часто встречающихся слов. tenMostCommon = FindTenMostCommon(words); }, () => { // Найти самое длинное слово. longestWord = FindLongestWord(words); }); // Когда все задачи завершены, построить строку, // показывающую все статистические данные. ...}Метод
Parallel.Invoke()Action<>Запросы Parallel LINQ (PLINQ)
В завершение знакомства с библиотекой TPL следует отметить, что существует еще один способ встраивания параллельных задач в приложения .NET Core. При желании можно применять набор расширяющих методов, которые позволяют конструировать запрос LINQ, распределяющий свою рабочую нагрузку по параллельным потокам (когда это возможно). Соответственно запросы LINQ, которые спроектированы для параллельного выполнения, называются запросами Parallel LINQ (PLINQ).
Подобно параллельному коду, написанному с использованием класса
ParallelВо время выполнения PLINQ анализирует общую структуру запроса, и если есть вероятность, что запрос выиграет от распараллеливания, то он будет выполняться параллельно. Однако если распараллеливание запроса ухудшит производительность, то PLINQ просто запустит запрос последовательно. Когда возникает выбор между потенциально затратным (в плане ресурсов) параллельным алгоритмом и экономным последовательным, предпочтение по умолчанию отдается последовательному алгоритму.
Необходимые расширяющие методы находятся в классе
ParallelEnumerableSystem.Linq
Чтобы взглянуть на PLINQ в действии, создайте проект консольного приложения по имени
PLINQDataProcessingWithCancellationSystem.LinqSystem.ThreadingSystem.Threading.Tasksusing System;using System.Linq;using System.Threading;using System.Threading.Tasks;Console.WriteLine("Start any key to start processing"); // Нажмите любую клавишу, чтобы начать обработкуConsole.ReadKey();Console.WriteLine("Processing");Task.Factory.StartNew(ProcessIntData);Console.ReadLine();void ProcessIntData(){ // Получить очень большой массив целых чисел. int[] source = Enumerable.Range(1, 10_000_000).ToArray(); // Найти числа, для которых истинно условие num % 3 == О, // и возвратить их в убывающем порядке. int[] modThreeIsZero = ( from num in source where num % 3 == 0 orderby num descending select num).ToArray(); // Вывести количество найденных чисел Console.WriteLine($"Found {modThreeIsZero.Count()} numbers that match query!");}Создание запроса PLINQ
Чтобы проинформировать библиотеку TPL о выполнении запроса в параллельном режиме (если такое возможно), необходимо использовать расширяющий метод
AsParallel()int[] modThreeIsZero = ( from num in source.AsParallel() where num % 3 == 0 orderby num descending select num).ToArray();Обратите внимание, что общий формат запроса LINQ идентичен тому, что вы видели в предыдущих главах. Тем не менее, за счет включения вызова
AsParallel()Отмена запроса PLINQ
С помощью объекта
CancellationTokenSourceProgramCancellationTokenSource_cancelTokenCancellationTokenSource _cancelToken = new CancellationTokenSource();do{ Console.WriteLine("Start any key to start processing"); // Нажмите любую клавишу, чтобы начать обработку Console.ReadKey(); Console.WriteLine("Processing"); Task.Factory.StartNew(ProcessIntData); Console.Write("Enter Q to quit: "); // Введите Q для выхода: string answer = Console.ReadLine(); // Желает ли пользователь выйти? if (answer.Equals("Q", StringComparison.OrdinalIgnoreCase)) { _cancelToken.Cancel(); break; }}while (true);Console.ReadLine();Теперь запрос PLINQ необходимо информировать о том, что он должен ожидать входящего запроса на отмену выполнения, добавив в цепочку вызов расширяющего метода
WithCancellation()try/catchProcessInData()void ProcessIntData(){ // Получить очень большой массив целых чисел. int[] source = Enumerable.Range(1, 10_000_000).ToArray(); // Найти числа, для которых истинно условие num % 3 == 0, // и возвратить их в убывающем порядке. int[] modThreeIsZero = null; try { modThreeIsZero = (from num in source.AsParallel().WithCancellation(_cancelToken.Token) where num % 3 == 0 orderby num descending select num).ToArray(); Console.WriteLine(); // Вывести количество найденных чисел. Console.WriteLine($"Found {modThreeIsZero.Count()} numbers that match query!"); } catch (OperationCanceledException ex) { Console.WriteLine(ex.Message); }}Во время выполнения метода
ProcessIntData()Асинхронные вызовы с помощью async/await
В этой довольно длинной главе было представлено много материала в сжатом виде. Конечно, построение, отладка и понимание сложных многопоточных приложений требует прикладывания усилий в любой инфраструктуре. Хотя TPL, PLINQ и тип делегата могут до некоторой степени упростить решение (особенно по сравнению с другими платформами и языками), разработчики по-прежнему должны хорошо знать детали разнообразных расширенных приемов.
С выходом версии .NET 4.5 в языке программирования C# появились два новых ключевых слова, которые дополнительно упрощают процесс написания асинхронного кода. По контрасту со всеми примерами, показанными ранее в главе, когда применяются ключевые слова
asyncawaitSystem.ThreadingSystem.Threading.TasksЗнакомство с ключевыми словами async и await языка C# (обновление в версиях 7.1, 9.0)
Ключевое слово
asyncasyncasyncawaitВ целях иллюстрации создайте новый проект консольного приложения по имени
FunWithCSharpAsyncProgram.csSystem.ThreadingSystem.Threading.TaskSystem.Collections.GenericDoWork()using System;using System.Collections.Generic;using System.Threading;using System.Threading.Tasks;Console.WriteLine(" Fun With Async ===>");Console.WriteLine(DoWork());Console.WriteLine("Completed");Console.ReadLine();static string DoWork(){ Thread.Sleep(5_000); return "Done with work!";}Вам известно, что после запуска программы придется ожидать пять секунд, прежде чем сможет произойти что-то еще. В случае графического приложения весь пользовательский интерфейс был бы заблокирован до тех пор, пока работа не завершится.
Если бы мы решили прибегнуть к одному из описанных ранее приемов, чтобы сделать приложение более отзывчивым, тогда пришлось бы немало потрудиться. Тем не менее, начиная с версии .NET 4.5, можно написать следующий код С#:
...string message = await DoWorkAsync();Console.WriteLine(message);...static string DoWork(){ Thread.Sleep(5_000); return "Done with work!";}static async Task DoWorkAsync() { return await Task.Run(() => { Thread.Sleep(5_000); return "Done with work!"; });}Если вы используете в качестве точки входа метод
Main()asyncstatic async Task Main(string[] args){ ... string message = await DoWorkAsync(); Conole.WriteLine(message); ...}На заметку! Возможность декорирования метода
Main()asyncОбратите внимание на ключевое слово
awaitasyncawaitКроме того, вы должны применять класс
TaskSystem.Threading.TasksMain()Main()DoWork()DoWorkAsync()stringTaskТРеализация метода
DoWorkAsync()TaskTask.Run()Run()Func<>Action<>DoWorkAsync()При вызове запускается новая задача, которая заставляет вызывающий поток уснуть на пять секунд. После завершения вызывающий поток предоставляет строковое возвращаемое значение. Эта строка помещается в новый объект
и возвращается вызывающему коду.Task
Благодаря новой реализации метода
DoWorkAsync()awaitTaskawaitCompletedDone with work!DoWorkAsync()Класс SynchronizationContext и async/await
Тип
SynchronizationContextЦель модели синхронизации, реализуемой классом
, заключается в том, чтобы позволить внутренним асинхронным/синхронным операциям общеязыковой исполняющей среды вести себя надлежащим образом с различными моделями синхронизации.SynchronizationContext
Наряду с тем, что вам уже известно о многопоточности, такое заявление проливает свет на этот вопрос. Вспомните, что приложения с графическим пользовательским интерфейсом (Windows Forms, WPF) не разрешают прямой доступ к элементам управления из вторичных потоков, а требуют делегирования доступа. Вы уже видели объект
DispatcherSynchronizationContextКласс
SynchonizationContextКак обсуждалось ранее, когда делегат помещается в очередь для асинхронного выполнения, он планируется к запуску в отдельном потоке, что обрабатывается средой .NET Core Runtime. Задача обычно решается с помощью управляемого пула потоков .NET Core Runtime, но может быть построена и специальная реализация.
Хотя такими связующими действиями можно управлять вручную в коде, шаблон
async/awaitawaitSynchronizationContextTaskSchedulerasync/awaitРоль метода ConfigureAwait()
Теперь, когда вы лучше понимаете роль класса
SynchronizationContextConfigureAwait()awaitTaskЧтобы увидеть все в действии, модифицируйте операторы верхнего уровня, как показано ниже:
Console.WriteLine(" Fun With Async ===>");// Console.WriteLine(DoWork());string message = await DoWorkAsync();Console.WriteLine(message);string message1 = await DoWorkAsync().ConfigureAwait(false);Console.WriteLine(message1);В исходном блоке кода применяется класс
SynchronizationContextConfigureAwait(true)Согласно рекомендациям команды создателей .NET Core при разработке прикладного кода (Windows Forms, WPF и т.д.) следует полагаться на стандартное поведение, а в случае написания неприкладного кода (скажем, библиотеки) использовать вызов
ConfigureAwait(false)SynchronizationContextConfigureAwait(false)Соглашения об именовании асинхронных методов
Конечно же, вы заметили, что мы изменили имя метода с
DoWork() DoWorkAsync()DoWork()// Отсутствует ключевое слово await!string message = DoWork();Обратите внимание, что мы действительно пометили метод ключевым словом
asyncDoWork()DoWork()TaskstringawaitTaskawaitНа заметку! Метод, поддерживающий
awaitTaskTaskС учетом того, что методы, которые возвращают объекты
TaskasyncawaitTaskAsyncawaitНа заметку! Обработчики событий для элементов управления графического пользовательского интерфейса (вроде обработчика события
ClickasyncawaitАсинхронные методы, возвращающие void
В настоящий момент наш метод
DoWorkAsync()TaskawaitvoidawaitАсинхронные методы, возвращающие void и поддерживающие await
Если асинхронный метод должен поддерживать
awaitTaskreturnstatic async Task MethodReturningTaskOfVoidAsync(){ await Task.Run(() => { /* Выполнить какую-то работу... */ Thread.Sleep(4_000); }); Console.WriteLine("Void method completed"); // Метод завершен}Затем в коде, вызывающем этот метод, примените ключевое слово
awaitMethodReturningVoidAsync();Console.WriteLine("Void method complete");Асинхронные методы, возвращающие void и работающие в стиле "запустил и забыл"
Если метод должен быть асинхронным, но не обязан поддерживать
awaitasyncvoidTaskstatic async void MethodReturningVoidAsync(){ await Task.Run(() => { /* Выполнить какую-то работу... */ Thread.Sleep(4_000); }); Console.WriteLine("Fire and forget void method completed"); // Метод завершен}Затем в коде, вызывающем этот метод, ключевое слово
awaitMethodReturningVoidAsync();Console.WriteLine("Void method complete");Асинхронные методы с множеством контекстов await
Внутри реализации асинхронного метода разрешено иметь множество контекстов
awaitstatic async Task MultipleAwaits(){ await Task.Run(() => { Thread.Sleep(2_000); }); Console.WriteLine("Done with first task!"); // Первая задача завершена! await Task.Run(() => { Thread.Sleep(2_000); }); Console.WriteLine("Done with second task!"); // Вторая задача завершена! await Task.Run(() => { Thread.Sleep(2_000); }); Console.WriteLine("Done with third task!"); // Третья задача завершена!}Здесь каждая задача всего лишь приостанавливает текущий поток на некоторый период времени; тем не менее, посредством таких задач может быть представлена любая единица работы (обращение к веб-службе, чтение базы данных или что-нибудь еще). Еще один вариант предусматривает ожидание не каждой отдельной задачи, а всех их вместе. Это более вероятный сценарий, когда имеются три работы (скажем, проверка поступления сообщений электронной почты, обновление сервера, загрузка файлов), которые должны делаться в пакете, но могут выполняться параллельно. Ниже приведен модифицированный код, в котором используется метод
Task.WhenAll()static async Task MultipleAwaits(){ var task1 = Task.Run(() => { Thread.Sleep(2_000); Console.WriteLine("Done with first task!"); }); var task2=Task.Run(() => { Thread.Sleep(1_000); Console.WriteLine("Done with second task!"); }); var task3 = Task.Run(() => { Thread.Sleep(1_000); Console.WriteLine("Done with third task!"); }); await Task.WhenAll(task1, task2, task3);}Запустив программу, вы увидите, что три задачи запускаются в порядке от наименьшего значения, указанного при вызове метода
Sleep()Fun With Async ===>Done with work!Void method completedDone with second task!Done with third task!Done with first task!CompletedСуществует также метод
WhenAnу()WhenAny()MultipleAwaits()await Task.WhenAny(task1, task2, task3);В результате вывод становится таким:
Fun With Async ===>Done with work!Void method completedDone with second task!CompletedDone with third task!Done with first task!Вызов асинхронных методов из неасинхронных методов
В каждом из предшествующих примеров ключевое слово
asyncawaitasyncasyncК счастью, существуют другие способы вызова асинхронных методов. Если вы просто не используете ключевое слово
awaitawaitПервый подход предусматривает просто использование свойства
ResultTaskWait()Task/TaskTaskTaskAggregateExceptionМожете также добавить вызов
GetAwaiter().GetResult()awaitasync/awaitGetAwaiter().GetResult()На заметку! Решение использовать свойство
ResultGetAwaiter().GetResult()TaskTaskGetAwaiter().GetResult()Wait()Например, вот как вы могли бы вызывать метод
DoWorkAsync()Console.WriteLine(DoWorkAsync().Result);Console.WriteLine(DoWorkAsync().GetAwaiter().GetResult());Чтобы остановить выполнение до тех пор, пока не произойдет возврат из метода с возвращаемым типом
voidWait()TaskMethodReturningVoidAsync().Wait();Ожидание с помощью await в блоках catch и finally
В версии C# 6 появилась возможность помещения вызовов await в блоки
catchfinallyasyncstatic async Task MethodWithTryCatch() { try { //Do some work return "Hello"; } catch (Exception ex) { await LogTheErrors(); throw; } finally { await DoMagicCleanUp(); }}Обобщенные возвращаемые типы в асинхронных методах (нововведение в версии 7.0)
До выхода версии C# 7 возвращаемыми типами методов
asyncTaskTaskvoidasyncValueTaskstatic async ValueTask ReturnAnInt() { await Task.Delay(1_000); return 5;}К типу
ValueTaskTaskValueTaskTaskЛокальные функции (нововведение в версии 7.0)
Локальные функции были представлены в главе 4 и использовались в главе 8 с итераторами. Они также могут оказаться полезными для асинхронных методов. Чтобы продемонстрировать преимущество, сначала нужно взглянуть на проблему. Добавьте новый метод по имени
MethodWithProblems()static async Task MethodWithProblems(int firstParam, int secondParam){ Console.WriteLine("Enter"); await Task.Run(() => { // Вызвать длительно выполняющийся метод Thread.Sleep(4_000); Console.WriteLine("First Complete"); // Вызвать еще один длительно выполняющийся метод, который терпит // неудачу из-за того, что значение второго параметра выходит // за пределы допустимого диапазона. Console.WriteLine("Something bad happened"); });}Сценарий заключается в том, что вторая длительно выполняющаяся задача терпит неудачу из-за недопустимых входных данных. Вы можете (и должны) добавить в начало метода проверки, но поскольку весь метод является асинхронным, нет никаких гарантий, что такие проверки выполнятся. Было бы лучше, чтобы проверки происходили непосредственно перед выполнением вызываемого кода. В приведенном далее обновленном коде проверки делаются в синхронной манере, после чего закрытая функция выполняется асинхронным образом.
static async Task MethodWithProblemsFixed(int firstParam, int secondParam){ Console.WriteLine("Enter"); if (secondParam < 0) { Console.WriteLine("Bad data"); return; } await actualImplementation(); async Task actualImplementation() { await Task.Run(() => { // Вызвать длительно выполняющийся метод Thread.Sleep(4_000); Console.WriteLine("First Complete"); // Вызвать еще один длительно выполняющийся метод, который терпит // неудачу из-за того, что значение второго параметра выходит // за пределы допустимого диапазона. Console.WriteLine("Something bad happened"); }); }}Отмена операций async/await
Шаблон
async/awaitParallel.ForEach()System.Drawing.Commondotnet new wpf -lang c# -n PictureHandlerWithAsyncAwait -o .\PictureHandlerWithAsyncAwait -f net5.0dotnet sln .\Chapter15_AllProjects.sln add .\PictureHandlerWithAsyncAwaitdotnet add PictureHandlerWithAsyncAwait package System.Drawing.CommonЕсли вы работаете в Visual Studio, тогда щелкните правой кнопкой мыши на имени решения в окне Solution Explorer, выберите в контекстном меню пункт Add►Project (Добавить►Проект) и назначьте ему имя
PictureHandlerWithAsyncAwaitSystem.Drawing.Commondotnet add PictureHandlerWithAsyncAwait package System.Drawing.CommonПриведите разметку XAML в соответствие с предыдущим проектом приложения WPF, но с заголовком
Picture Handler with Async/AwaitУдостоверьтесь, что в файле
MainWindow.xaml.csusingusing System;using System.IO;using System.Threading;using System.Threading.Tasks;using System.Windows;using System.Drawing;Затем добавьте переменную уровня класса для объекта
CancellationTokenprivate CancellationTokenSource _cancelToken = null;private void cmdCancel_Click(object sender, EventArgs e){ _cancelToken.Cancel();}Процесс здесь такой же, как в предыдущем примере: получение каталога с файлами изображений, создание выходного каталога, получение файлов, поворот изображений в файлах и сохранение их в выходном каталоге. В новой версии для выполнения работы будут применяться асинхронные методы, а не
Parallel.ForEach()CancellationTokenprivate async void cmdProcess_Click(object sender, EventArgs e){ _cancelToken = new CancellationTokenSource(); var basePath = Directory.GetCurrentDirectory(); var pictureDirectory = Path.Combine(basePath, "TestPictures"); var outputDirectory = Path.Combine(basePath, "ModifiedPictures"); // Удалить любые существующие файлы if (Directory.Exists(outputDirectory)) { Directory.Delete(outputDirectory, true); } Directory.CreateDirectory(outputDirectory); string[] files = Directory.GetFiles( pictureDirectory, "*.jpg", SearchOption.AllDirectories); try { foreach(string file in files) { try { await ProcessFile( file, outputDirectory,_cancelToken.Token); } catch (OperationCanceledException ex) { Console.WriteLine(ex); throw; } } } catch (OperationCanceledException ex) { Console.WriteLine(ex); throw; } catch (Exception ex) { Console.WriteLine(ex); throw; } _cancelToken = null; this.Title = "Processing complete";}После начальных настроек в коде организуется цикл по файлам с асинхронным вызовом метода
ProcessFile()ProcessFile()try/catchCancellationTokenCancel()CancellationTokenSourceOperationCanceledExceptionНа заметку! Код
try/catchНаконец, добавьте финальный метод
ProcessFile()private async Task ProcessFile(string currentFile, string outputDirectory, CancellationToken token){ string filename = Path.GetFileName(currentFile); using (Bitmap bitmap = new Bitmap(currentFile)) { try { await Task.Run(() => { Dispatcher?.Invoke(() => { this.Title = $"Processing {filename}"; }); bitmap.RotateFlip(RotateFlipType.Rotate180FlipNone); bitmap.Save(Path.Combine(outputDirectory, filename)); } ,token); } catch (OperationCanceledException ex) { Console.WriteLine(ex); throw; } }}Метод
ProcessFile()Task.Run()CancellationTokenTask.Run()try/catchАсинхронные потоки (нововведение в версии 8.0)
В версии C# 8.0 появилась возможность создания и потребления потоков данных (раскрываются в главе 20) асинхронным образом. Метод, который возвращает асинхронный поток данных:
• объявляется с модификатором
async• возвращает реализацию
IAsyncEnumerable• содержит операторы
yield returnВзгляните на приведенный далее пример:
public static async IAsyncEnumerable GenerateSequence() { for (int i = 0; i < 20; i++) { await Task.Delay(100); yield return i; }}Метод
GenerateSequence()asyncIAsyncEnumerableyield returnawait foreach (var number in GenerateSequence()){ Console.WriteLine(number);}Итоговые сведения о ключевых словах async и await
Настоящий раздел содержал много примеров; ниже перечислены ключевые моменты, которые в нем рассматривались.
• Методы (а также лямбда-выражения или анонимные методы) могут быть помечены ключевым словом
async• Методы (а также лямбда-выражения или анонимные методы), помеченные ключевым словом
asyncawait• Один метод
asyncawait• Когда встречается выражение
await• Ключевое слово
awaitTaskvoid• Проверка параметров и другая обработка ошибок должна делаться в главной части метода с переносом фактической порции
async• Для переменных, находящихся в стеке, объект
ValueTaskTask• По соглашению об именовании методы, которые могут вызываться асинхронно, должны быть помечены с помощью суффикса
AsyncРезюме
Глава начиналась с исследования роли пространства имен
System.ThreadingЗатем в главе исследовались новые модели для разработки многопоточных приложений, введенные в .NET 4.0, в частности Task Parallel Library и PLINQ. В завершение главы была раскрыта роль ключевых слов
asyncawait
ТЕЛЕГРАМКанал с обзорами, анонсами новинок и книжными подборками
Книжный Вестник
Бот для удобного поиска книг (если не нашлось на сайте)
Поиск книг
Свежие любовные романы в удобных форматах
Любовные романы
О психологии, саморазвитии и личностном росте
Саморазвитие
Детективы и триллеры, все новинки
Детективы
Фантастика и фэнтези, все новинки
Фантастика
Отборные классические книги
Классика
ВКОНТАКТЕБиблиотека с любовными романами, которая наверняка придётся по вкусу женской части аудитории
Любовные романы
Библиотека с фантастикой и фэнтези, а также смежных жанров
Фантастика
Самые популярные книги в формате фб2
Топ фб2
книги