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

Троелсен Эндрю

// Определение целочисленных переменных в С #.

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.

• Правило номер 1. Правила CLS применяются только к тем частям типа, которые видны извне определяющей сборки.

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

В целях иллюстрации ниже представлен метод

Add

в С#, который не совместим с CLS, поскольку его параметры и возвращаемое значение используют данные без знака (что не является требованием CLS):

class Calc

{

//

Открытые для доступа данные без знака не совместимы с CLS!

public ulong Add(ulong addendl, ulong addend2)

{

return addendl + addend2;

}

}

Тем не менее, взгляните на следующий класс, который взаимодействует с данными без знака внутри метода:

class Calc

{

public int Add(int addendl, int addend2)

{

// Поскольку эта переменная ulong используется только

// внутренне, совместимость с CLS сохраняется.

ulong temp = 0;

...

return addendl + addend2;

}

}

Класс

Calc

по-прежнему соблюдает правила CLS и можно иметь уверенность в том, что все языки .NET Core смогут вызывать его метод

Add

.

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

Обеспечение совместимости с CLS

Как вы увидите при чтении книги, в языке C# определено несколько программных конструкций, несовместимых с CLS. Однако хорошая новость заключается в том, что компилятор C# можно инструктировать о необходимости проверки кода на предмет совместимости с CLS, используя единственный атрибут .NET Core:

// Сообщить компилятору C# о том, что он должен

// осуществлять проверку на совместимость с CLS.

[assembly: CLSCompliant(true) ]

Детали программирования на основе атрибутов подробно рассматриваются в главе 17. А пока следует просто запомнить, что атрибут

[CLSCompliant]

заставляет компилятор C# проверять каждую строку кода на соответствие правилам CLS. В случае обнаружения любых нарушений спецификации CLS компилятор выдаст предупреждение с описанием проблемного кода.

Понятие .NET Core Runtime

В дополнение к спецификациям CTS и CLS осталось рассмотреть финальный фрагмент головоломки — .NET Core Runtime или просто .NET Runtime. В рамках программирования термин исполняющая среда можно понимать как коллекцию служб, которые требуются для выполнения скомпилированной единицы кода. Например, когда разработчики на Java развертывают программное обеспечение на новом компьютере, им необходимо удостовериться в том, что на компьютере установлена виртуальная машина Java (Java Virtual Machine — JVM), которая обеспечит выполнение их программного обеспечения.