Двухэтапная компиляция. Управляемый модуль и управляемый код

Компиляторы языков программирования, включенные в Visual Studio.Net, создают модули на промежуточном языке MSIL (Microsoft Intermediate Language), называемом далее просто - IL. Фактически компиляторы создают так называемый управляемый модуль - переносимый исполняемый файл (Portable Executable или PE-файл). Этот файл содержит код на IL и метаданные - всю необходимую информацию как для CLR, так и конечных пользователей, работающих с приложением. О метаданных - важной новинке Framework.Net - мы еще будем говорить неоднократно. В зависимости от выбранного типа проекта, PE-файл может иметь уточнения exe, dll, mod или mdl.

Заметьте, PE-файл, имеющий уточнение exe, хотя и является exe-файлом, но это не совсем обычный, исполняемый Windows, файл. При его запуске он распознается как специальный PE-файл и передается CLR для обработки. Исполнительная среда начинает работать с кодом, в котором специфика исходного языка программирования исчезла. Код на IL начинает выполняться под управлением CLR (по этой причине код называется управляемым). Исполнительную среду можно рассматривать как своеобразную виртуальную IL-машину. Эта машина транслирует "на лету" требуемые для исполнения участки кода в команды реального процессора, который в действительности и выполняет код.

2. Лекция: Язык C# и первые проекты

Создание языка. Его особенности. Решения, проекты, пространства имен. Консольные и Windows-приложения C#, построенные по умолчанию.

Создание C#

Язык C# является наиболее известной новинкой в области создания языков программирования. В отличие от 60-х годов XX века - периода бурного языкотворчества - в нынешнее время языки создаются крайне редко. За последние 15 лет большое влияние на теорию и практику программирования оказали лишь два языка: Eiffel, лучший, по моему мнению, объектно-ориентированный язык, и Java, ставший популярным во многом благодаря технологии его использования в Интернете и появления такого понятия как виртуальная Java-машина. Чтобы новый язык получил признание, он должен действительно обладать принципиально новыми качествами. Языку C# повезло с родителями. Явившись на свет в недрах Microsoft, будучи наследником C++, он с первых своих шагов получил мощную поддержку. Однако этого явно недостаточно для настоящего признания достоинств языка. Попробуем разобраться, имеет ли он большое будущее?

Как отмечал сам Андреас Хейлсберг, C# создавался как язык компонентного программирования, и в этом одно из главных достоинств языка, направленное на возможность повторного использования созданных компонентов. Из других объективных факторов отметим следующие:

• C# создавался параллельно с каркасом Framework.Net и в полной мере учитывает все его возможности - как FCL, так и CLR;
• C# является полностью объектно-ориентированным языком, где даже типы, встроенные в язык, представлены классами;
• C# является мощным объектным языком с возможностями наследования и универсализации;
• C# является наследником языков C/C++, сохраняя лучшие черты этих популярных языков программирования. Общий с этими языками синтаксис, знакомые операторы языка облегчают переход программистов от С++ к C#;
• сохранив основные черты своего великого родителя, язык стал проще и надежнее. Простота и надежность, главным образом, связаны с тем, что на C# хотя и допускаются, но не поощряются такие опасные свойства С++ как указатели, адресация, разыменование, адресная арифметика;
• благодаря каркасу Framework.Net, ставшему надстройкой над операционной системой, программисты C# получают те же преимущества работы с виртуальной машиной, что и программисты Java. Эффективность кода даже повышается, поскольку исполнительная среда CLR предоставляет собой компилятор промежуточного языка, в то время как виртуальная Java-машина является интерпретатором байт-кода;
• мощная библиотека каркаса поддерживает удобство построения различных типов приложений на C#, позволяя легко строить Web-службы, другие виды компонентов, достаточно просто сохранять и получать информацию из базы данных и других хранилищ данных;
• реализация, сочетающая построение надежного и эффективного кода, является немаловажным фактором, способствующим успеху C#.

Виды проектов

Как уже отмечалось, Visual Studio.Net для языков C#, Visual Basic и J# предлагает 12 возможных видов проектов. Среди них есть пустой проект, в котором изначально не содержится никакой функциональности; есть также проект, ориентированный на создание Web-служб. В этой книге, направленной, прежде всего, на изучение языка C#, основным видом используемых проектов будут обычные Windows-приложения. На начальных этапах, чтобы не усложнять задачу проблемами пользовательского интерфейса, будем рассматривать также консольные приложения.

Давайте разберемся, как создаются проекты и что они изначально собой представляют. Поговорим также о сопряженных понятиях: решение (solution), проект (project), пространство имен (namespace), сборка (assembly). Рассмотрим результаты работы компилятора Visual Studio с позиций программиста, работающего над проектом, и с позиций CLR, компилирующей PE-файл в исходный код процессора.

С точки зрения программиста, компилятор создает решение, с точки зрения CLR - сборку, содержащую PE-файл. Программист работает с решением, CLR - со сборкой.

Решение содержит один или несколько проектов, ресурсы, необходимые этим проектам, возможно, дополнительные файлы, не входящие в проекты. Один из проектов решения должен быть выделен и назначен стартовым проектом. Выполнение решения начинается со стартового проекта. Проекты одного решения могут быть зависимыми или независимыми. Например, все проекты одной лекции данной книги могут быть для удобства собраны в одном решении и иметь общие свойства. Изменяя стартовый проект, получаем возможность перехода к нужному примеру. Заметьте, стартовый проект должен иметь точку входа - класс, содержащий статическую процедуру с именем Main, которой автоматически передается управление в момент запуска решения на выполнение. В уже имеющееся решение можно добавлять как новые, так и существующие проекты. Один и тот же проект может входить в несколько решений.

Проект состоит из классов, собранных в одном или нескольких пространствах имен. Пространства имен позволяют структурировать проекты, содержащие большое число классов, объединяя в одну группу близкие классы. Если над проектом работает несколько исполнителей, то, как правило, каждый из них создает свое пространство имен. Помимо структуризации, это дает возможность присваивать классам имена, не задумываясь об их уникальности. В разных пространствах имен могут существовать одноименные классы. Проект - это основная единица, с которой работает программист. Он выбирает тип проекта, а Visual Studio создает скелет проекта в соответствии с выбранным типом.

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

Консольный проект

У себя на компьютере я открыл установленную лицензионную версию Visual Studio.Net 2003, выбрал из предложенного меню - создание нового проекта на C#, установил вид проекта - консольное приложение, дал имя проекту - ConsoleHello, указал, где будет храниться проект. Как выглядит задание этих установок, показано на рис. 2.1.

Рис. 2.1. Окно создания нового проекта

Если принять эти установки, то компилятор создаст решение, имя которого совпадает с именем проекта. На рис. 2.2 показано, как выглядит это решение в среде разработки:

Рис. 2.2. Среда разработки и консольное приложение, построенное по умолчанию

Интегрированная среда разработки IDE (Integrated Development Envirionment) Visual Studio является многооконной, настраиваемой, обладает большим набором возможностей. Внешний вид ее достаточно традиционен, хотя здесь есть новые возможности; я не буду заниматься ее описанием, полагаясь на опыт читателя и справочную систему. Обращаю внимание лишь на три окна, из тех, что показаны на рис. 2.2. В окне Solution Explorer представлена структура построенного решения. В окне Properties можно увидеть свойства выбранного элемента решения. В окне документов отображается выбранный документ, в данном случае, программный код класса проекта - ConsoleHello.Class1. Заметьте, в этом окне можно отображать и другие документы, список которых показан в верхней части окна.

Построенное решение содержит, естественно, единственный заданный нами проект - ConsoleHello. Наш проект, как показано на рис. 2.2, включает в себя папку со ссылками на системные пространства имен из библиотеки FCL, файл со значком приложения и два файла с уточнением cs. Файл AssemblyInfo содержит информацию, используемую в сборке, а файл со стандартным именем Class1 является построенным по умолчанию классом, который задает точку входа - процедуру Main, содержащую для данного типа проекта только комментарий.

Заметьте, класс проекта погружен в пространство имен, имеющее по умолчанию то же имя, что и решение, и проект. Итак, при создании нового проекта автоматически создается достаточно сложная вложенная структура - решение, содержащее проект, содержащий пространство имен, содержащее класс, содержащий точку входа. Для простых решений такая структурированность представляется избыточной, но для сложных - она осмысленна и полезна.

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

Пространству имен может предшествовать одно или несколько предложений using, где после ключевого слова следует название пространства имен - из библиотеки FCL или из проектов, связанных с текущим проектом. В данном случае задается пространство имен System - основное пространство имен библиотеки FCL. Предложение using NameA облегчает запись при использовании классов, входящих в пространство NameA, поскольку в этом случае не требуется каждый раз задавать полное имя класса с указанием имени пространства, содержащего этот класс. Чуть позже мы увидим это на примере работы с классом Console пространства System. Заметьте, полное имя может потребоваться, если в нескольких используемых пространствах имен имеются классы с одинаковыми именами.

Все языки допускают комментарии. В C#, как и в С++, допускаются однострочные и многострочные комментарии. Первые начинаются с двух символов косой черты. Весь текст до конца строки, следующий за этой парой символов, (например, "//любой текст") воспринимается как комментарий, не влияющий на выполнение программного кода. Началом многострочного комментария является пара символов /*, а концом - */. Заметьте, тело процедуры Main содержит три однострочных комментария.

Здесь же, в проекте, построенном по умолчанию, мы встречаемся с еще одной весьма важной новинкой C# - XML-тегами, формально являющимися частью комментария. Отметим, что описанию класса Class1 и описанию метода Main предшествует заданный в строчном комментарии XML-тег <summary>. Этот тэг распознается специальным инструментарием, строящим XML-отчет проекта. Идея самодокументируемых программных проектов, у которых документация является неотъемлемой частью, является важной составляющей стиля компонентного надежного программирования на C#. Мы рассмотрим реализацию этой идеи в свое время более подробно, но уже с первых шагов будем использовать теги документирования и строить XML-отчеты. Заметьте, кроме тега <summary> возможны и другие тэги, включаемые в отчеты. Некоторые теги добавляются почти автоматически. Если в нужном месте (перед объявлением класса, метода) набрать подряд три символа косой черты, то автоматически вставится тэг документирования, так что останется только дополнить его соответствующей информацией.

2. Лекция: Язык C# и первые проекты

Еще одна новинка C#, встречающаяся в начальном проекте, это атрибут [STAThread], который предшествует описанию процедуры Main. Так же, как и тэги документирования, атрибуты распознаются специальным инструментарием и становятся частью метаданных. Атрибуты могут быть как стандартными, так и заданными пользователем. Стандартные атрибуты используются CLR и влияют на то, как она будет выполнять проект. В данном случае атрибут [STAThread] (Single Thread Apartment) задает однопоточную модель выполнения. Об атрибутах и метаданных мы еще будем говорить подробно. Заметьте, если вы нечетко представляете, каков смысл однопоточной модели, и не хотите, чтобы в вашем тексте присутствовали непонятные для вас указания, то этот атрибут можно удалить из текста, что не отразится на выполнении.

Скажем еще несколько слов о точке входа - процедуре Main. Ее заголовок можно безболезненно упростить, удалив аргументы, которые, как правило, не задаются. Они имеют смысл, когда проект вызывается из командной строки, позволяя с помощью параметров задать нужную стратегию выполнения проекта.

Таков консольный проект, построенный по умолчанию. Функциональности у него немного. Его можно скомпилировать, выбрав соответствующий пункт из меню build. Если компиляция прошла без ошибок, то в результате будет произведена сборка и появится PE-файл в соответствующей папке Debug нашего проектa. Приложение можно запустить нажатием соответствующих клавиш (например, CTRL+F5) или выбором соответствующего пункта из меню Debug. Приложение будет выполнено под управлением CLR. В результате выполнения появится консольное окно с предложением нажать любую клавишу для закрытия окна.

Слегка изменим проект, построенный по умолчанию, добавим в него свой код и превратим его в классический проект приветствия. Нам понадобятся средства для работы с консолью - чтения с консоли (клавиатуры) и вывода на консоль (дисплей) строки текста. Библиотека FCL предоставляет для этих целей класс Console, среди многочисленных методов которого есть методы ReadLine и WriteLine с очевидной семантикой. Вот код проектa, полученный в результате моих корректировок:

using System;namespace ConsoleHello{ /// <summary> /// Первый консольный проект - Приветствие /// </summary> class Class1 { /// <summary> /// Точка входа. Запрашивает имя и выдает приветствие /// </summary> static void Main() { Console.WriteLine("Введите Ваше имя"); string name; name = Console.ReadLine(); if (name=="") Console.WriteLine ("Здравствуй, мир!"); else Console.WriteLine("Здравствуй, " + name + "!"); } }}

Я изменил текст в тегах <summary>, удалил атрибут и аргументы процедуры Main, добавил в ее тело операторы ввода-вывода. Благодаря предложению using, мне не требуется при вызове методов класса Console каждый раз писать System.Console. Надеюсь, что программный текст понятен без дальнейших пояснений.

В завершение первого проектa построим его XML-отчет. Для этого в свойствах проектa необходимо указать имя файла, в котором будет храниться отчет. Установка этого свойства проектa, так же как и других свойств, делается в окне Property Pages, открыть которое можно по-разному. Я обычно делаю это так: в окне Solution Explorer выделяю строку с именем проектa, а затем в окне Properties нажимаю имеющуюся там кнопку Property Pages. Затем в открывшемся окне свойств, показанном на рис. 2.3, устанавливается нужное свойство. В данном случае я задал имя файла отчета hello.xml.

Рис. 2.3. Окно Property Pages проекта и задание имени XML-отчета

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

<?xml version="1.0"?><doc><assembly> <name>ConsoleHello</name></assembly><members> <member name="T:ConsoleHello.Class1"> <summary> Первый консольный проект - Приветствие </summary> </member> <member name="M:ConsoleHello.Class1.Main"> <summary> Точка входа. Запрашивает имя и_выдает приветствие </summary> </member></members></doc>

Как видите, отчет описывает наш проект, точнее, сборку. Пользователь, пожелавший воспользоваться этой сборкой, из отчета поймет, что она содержит один класс, назначение которого указано в теге <summary>. Класс содержит лишь один элемент - точку входа Main с заданной спецификацией в теге <summary>.

3. Лекция. Система типов языка C#

Общий взгляд. Система типов. Типы-значения и ссылочные типы. Встроенные типы. Сравнение с типами C++. Типы или классы? И типы, и классы! Преобразования переменных в объекты и vice versa. Операции "упаковать" и "распаковать". Преобразования типов. Преобразования внутри арифметического типа. Преобразования строкового типа. Класс Convert и его методы. Проверяемые преобразования. Управление проверкой арифметических преобразований.

Общий взгляд

Знакомство с новым языком программирования разумно начинать с изучения системы типов этого языка. Как в нем устроена система типов данных? Какие есть простые типы, как создаются сложные, структурные типы, как определяются собственные типы, динамические типы, как определяются классы?

Классы и объекты впервые появились в программировании в языке Симула 67. Определение класса наряду с описанием данных содержало четкое определение операций или методов, применимых к данным. Объекты - экземпляры класса являются обобщением понятия переменной. Сегодня определение класса в C# и других объектных языках, аналогично определению типа в CTS, содержит:

• данные, задающие свойства объектов класса;
• методы, определяющие поведение объектов класса;
• события, которые могут происходить с объектами класса.

Так есть ли различие между этими двумя основополагающими понятиями - типом и классом? На первых порах можно считать, что класс - это хорошо определенный тип данных, объект - хорошо определенная переменная. Понятия фактически являются синонимами, какое из них употреблять лишь дело вкуса. Встроенные типы, такие как integer или string, предпочитают называть по-прежнему типами, а их экземпляры - переменными. Что же касается абстракции данных, описывающей служащих и названной, например, Employee, то естественнее называть ее классом, а ее экземпляры - объектами. Такой взгляд на типы и классы довольно полезен, но он не является полным. Позже при обсуждении классов и наследования постараемся более четко определить принципиальные различия в этих понятиях.

Типы данных принято разделять на простые и сложные в зависимости от того, как устроены их данные. У простых (скалярных) типов возможные значения данных едины и неделимы. Сложные типы характеризуются способом структуризации данных - одно значение сложного типа состоит из множества значений данных, организующих сложный тип.

Есть и другие критерии классификации типов. Так, типы разделяются на встроенные типы и типы, определенные программистом (пользователем). Встроенные типы изначально принадлежат языку программирования и составляют его базис. В основе системы типов любого языка программирования всегда лежит базисная система типов, встроенных в язык. На их основе программист может строить собственные, им самим определенные типы данных. Но способы (правила) создания таких типов являются базисными, встроенными в язык.

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

Еще одна важная классификация типов - это их деление на значимые и ссылочные. Для значимых типов значение переменной (объекта) является неотъемлемой собственностью переменной (точнее, собственностью является память, отводимая значению, а само значение может изменяться). Для ссылочных типов значением служит ссылка на некоторый объект в памяти, расположенный обычно в динамической памяти - "куче". Объект, на который указывает ссылка, может быть разделяемым. Это означает, что несколько ссылочных переменных могут указывать на один и тот же объект и разделять его значения. Значимый тип принято называть развернутым, подчеркивая тем самым, что значение объекта развернуто непосредственно в памяти, отводимой объекту. О ссылочных и значимых типах еще предстоит обстоятельный разговор.

Для большинства процедурных языков, реально используемых программистами - Паскаль, C++, Java, Visual Basic, C#, - система встроенных типов более или менее одинакова. Всегда в языке присутствуют арифметический, логический (булев), символьный типы. Арифметический тип всегда разбивается на подтипы. Всегда допускается организация данных в виде массивов и записей (структур). Внутри арифметического типа всегда допускаются преобразования, всегда есть функции, преобразующие строку в число и обратно. Так что, мой читатель, Ваше знание, по крайней мере, одного из процедурных языков позволяет построить общую картину системы типов и для языка C#.

Система типов

Согласно этой классификации все типы можно разделить на четыре категории:

1. Типы-значения (value), или значимые типы.
2. Ссылочные (reference).
3. Указатели (pointer).
4. Тип void.

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

В отдельную категорию выделены указатели, что подчеркивает их особую роль в языке. Указатели имеют ограниченную область действия и могут использоваться только в небезопасных блоках, помеченных как unsafe.

Особый статус имеет и тип void, указывающий на отсутствие какого-либо значения.

В языке C# жестко определено, какие типы относятся к ссылочным, а какие - к значимым. К значимым типам относятся: логический, арифметический, структуры, перечисление. Массивы, строки и классы относятся к ссылочным типам. На первый взгляд, такая классификация может вызывать некоторое недоумение, почему это структуры, которые в C++ близки к классам, относятся к значимым типам, а массивы и строки - к ссылочным. Однако ничего удивительного здесь нет. В C# массивы рассматриваются как динамические, их размер может определяться на этапе вычислений, а не в момент трансляции. Строки в C# также рассматриваются как динамические переменные, длина которых может изменяться. Поэтому строки и массивы относятся к ссылочным типам, требующим распределения памяти в "куче".

Со структурами дело сложнее. Структуры C# представляют частный случай класса. Определив свой класс как структуру, программист получает возможность отнести класс к значимым типам, что иногда бывает крайне полезно. Замечу, что в хорошем объектном языке Eiffel программист может любой класс объявить развернутым (expanded), что эквивалентно отнесению к значимому типу. У программиста C# только благодаря структурам появляется возможность управлять отнесением класса к значимым или ссылочным типам. Правда, это неполноценное средство, поскольку на структуры накладываются дополнительные ограничения по сравнению с обычными классами.

Рассмотрим классификацию, согласно которой все типы делятся на встроенные и определенные пользователем. Все встроенные типы C# однозначно отображаются, а фактически совпадают с системными типами каркаса Net Framework, размещенными в пространстве имен System. Поэтому всюду, где можно использовать имя типа, например, - int, с тем же успехом можно использовать и имя System.Int32.

Следует понимать тесную связь и идентичность встроенных типов языка C# и типов каркаса. Какими именами типов следует пользоваться в программных текстах - это спорный вопрос. Джеффри Рихтер в своей известной книге "Программирование на платформе Framework.Net" рекомендует использовать системные имена. Другие авторы считают, что следует пользоваться именами типов, принятыми в языке. Возможно, в модулях, предназначенных для межъязыкового взаимодействия, разумны системные имена, а в остальных случаях - имена конкретного языка программирования.

В заключение этого раздела приведу таблицу (3.1), содержащую описание всех встроенных типов языка C# и их основные характеристики.

3. Лекция. Система типов языка C#

Логический тип
Имя типа	Системный тип	Значения	Размер
Bool	System.Boolean	true, false	8 бит
Арифметические целочисленные типы
Имя типа	Системный тип	Диапазон	Размер
Sbyte	System.SByte	-128 — 127	Знаковое, 8 Бит
Byte	System.Byte	0 — 255	Беззнаковое, 8 Бит
Short	System.Short	-32768 —32767	Знаковое, 16 Бит
Ushort	System.UShort	0 — 65535	Беззнаковое, 16 Бит
Int	System.Int32	≈(-2*10^9 — 2*10^9)	Знаковое, 32 Бит
Uint	System.UInt32	≈(0 — 4*10^9)	Беззнаковое, 32 Бит
Long	System.Int64	≈(-9*10^18 — 9*10^18)	Знаковое, 64 Бит
Ulong	System.UInt64	≈(0— 18*10^18)	Беззнаковое, 64 Бит
Арифметический тип с плавающей точкой
Имя типа	Системный тип	Диапазон	Точность
Float	System.Single	+1.5*10^-45 - +3.4*10^38	7 цифр
Double	System.Double	+5.0*10^-324 - +1.7*10^308	15-16 цифр
Арифметический тип с фиксированной точкой
Имя типа	Системный тип	Диапазон	Точность
Decimal	System.Decimal	+1.0*10^-28 - +7.9*10^28	28-29 значащих цифр
Символьные типы
Имя типа	Системный тип	Диапазон	Точность
Char	System.Char	U+0000 - U+ffff	16 бит Unicode символ
String	System.String	Строка из символов Unicode
Объектный тип
Имя типа	Системный тип	Примечание
Object	System.Object	Прародитель всех встроенных и пользовательских типов

 

Система встроенных типов языка C# не только содержит практически все встроенные типы (за исключением long double) стандарта языка C++, но и перекрывает его разумным образом. В частности тип string является встроенным в язык, что вполне естественно. В области совпадения сохранены имена типов, принятые в C++, что облегчает жизнь тем, кто привык работать на C++, но собирается по тем или иным причинам перейти на язык C#.