Язык программирования C#9 и платформа .NET5

  public void PrintPosition
  {
  Console.WriteLine("({0}, {!})", xPos, yPos);
  }
 }

Типы перечислений CTS

Перечисления — это удобная программная конструкция, которая позволяет группировать пары "имя-значение". Например, предположим, что требуется создать игровое приложение, в котором игроку разрешено выбирать персонажа из трех категорий:

Wizard (маг), Fighter (воин) или Thief (вор). Вместо отслеживания простых числовых значений, представляющих каждую категорию, можно было бы создать строго типизированное перечисление, используя ключевое слово enum:

  // Тип перечисления C#.
 enum CharacterType
 {
  Wizard = 100,
  Fighter = 200,
  Thief = 300
 }

По умолчанию для хранения каждого элемента выделяется блок памяти, соответствующий 32-битному целому, однако при необходимости (скажем, при программировании для устройств с малым объемом памяти наподобие мобильных устройств) область хранения можно изменить. Кроме того, спецификация CTS требует, чтобы перечислимые типы были производными от общего базового класса System.Enum. Как будет показано в главе 4, в этом базовом классе определено несколько интересных членов, которые позволяют извлекать, манипулировать и преобразовывать лежащие в основе пары "имя-значение" программным образом.

Типы делегатов CTS

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

  // Этот тип делегата C# может "указывать" на любой метод,
  // возвращающий тип int и принимающий два значения int.
 delegate int BinaryOp(int x, int y);

Делегаты критически важны, когда объект необходимо наделить возможностью перенаправления вызова другому объекту, и они формируют основу архитектуры событий .NET Core. Как будет показано в главах 12 и 14, делегаты обладают внутренней поддержкой группового вызова (т.е. перенаправления запроса множеству получателей) и асинхронного вызова методов (т.е. вызова методов во вторичном потоке).

Члены типов CTS

Теперь, когда было представлено краткое описание каждого типа, формализованного в CTS, следует осознать тот факт, что большинство таких типов располагает любым количеством членов. Формально член типа ограничен набором {конструктор, финализатор, статический конструктор, вложенный тип, операция, метод, свойство, индексатор, поле, поле только для чтения, константа, событие}.

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

На заметку! Как объясняется в главе 10, в языке C# также поддерживается создание обобщенных типов и обобщенных членов.

Встроенные типы данных CTS

Финальный аспект спецификации CTS, о котором следует знать на текущий момент, заключается в том, что она устанавливает четко определенный набор фундаментальных типов данных. Хотя в каждом отдельном языке для объявления фундаментального типа данных обычно имеется уникальное ключевое слово, ключевые слова всех языков .NET Core в конечном итоге распознаются как один и тот же тип CTS, определенный в сборке по имени mscorlib.dll. В табл. 1.2 показано, каким образом основные типы данных CTS выражаются в языках VB. NET и С#.

Учитывая, что уникальные ключевые слова в управляемом языке являются просто сокращенными обозначениями для реальных типов в пространстве имен System, больше не нужно беспокоиться об условиях переполнения/потери значимости для числовых данных или о том, как строки и булевские значения внутренне представляются в разных языках. Взгляните на следующие фрагменты кода, в которых определяются 32-битные целочисленные переменные в C# и Visual Basic с применением ключевых слов языка, а также формального типа данных CTS:

  // Определение целочисленных переменных в С #.
 int i = 0;
 System.Int32 j = 0;

  ' Определение целочисленных переменных в VB.
 Dim i As Integer = 0
 Dim j As System.Int32 = 0

Понятие общеязыковой спецификации

Как вы уже знаете, разные языки программирования выражают одни и те же программные конструкции с помощью уникальных и специфичных для конкретного языка терминов. Например, в C# конкатенация строк обозначается с использованием операции "плюс" (+), а в VB для этого обычно применяется амперсанд (&). Даже если два разных языка выражают одну и ту же программную идиому (скажем, функцию, не возвращающую значение), то высока вероятность того, что синтаксис на первый взгляд будет выглядеть не сильно отличающимся:

  // Ничего не возвращающий метод С #.
 public void MyMethodO
 {
   // Некоторый код...
 }
  ' Ничего не возвращающий метод VB.
 Public Sub MyMethodO
   ' Некоторый код...
 End Sub

Ранее вы уже видели, что такие небольшие синтаксические вариации для исполняющей среды .NET Core несущественны, учитывая, что соответствующие компиляторы (в данном случае csc.exe и vbc.exe) выпускают похожий набор инструкций CIL. Тем не менее, языки могут также отличаться в отношении общего уровня функциональности. Например, язык .NET Core может иметь или не иметь ключевое слово для представления данных без знака и поддерживать или не поддерживать типы указателей. При таких возможных вариациях было бы идеально располагать опорными требованиями, которым удовлетворяли бы все языки .NET Core.

Спецификация CLS — это набор правил, подробно описывающих минимальное и полное множество характеристик, которые отдельный компилятор .NET Core должен поддерживать, чтобы генерировать код, обслуживаемый средой CLR и в то же время доступный в унифицированной манере всем ориентированным на платформу .NET Core языкам. Во многих отношениях CLS можно рассматривать как подмножество полной функциональности, определенной в CTS.

В конечном итоге CLS является набором правил, которых должны придерживаться создатели компиляторов, если они намерены обеспечить гладкое функционирование своих продуктов в мире .NET Core. Каждое правило имеет простое название (например, "Правило номер 6"), и каждое правило описывает воздействие на тех, кто строит компиляторы, и на тех, кто (каким-либо образом) взаимодействует с ними. Самым важным в CLS является правило номер 1.