Алексей Вуколов
Елена Филиппова
Игорь Шевченко
дата публикации 01-12-2004 12:47

---

Версия для печати

После загрузки среды перед нами возникает приветственная страница "Welcome Page". Это новый аналог того самого окошка новостей, которое выглядело довольно неказисто, если ваш компьютер не был подключен к интернету во время работы. Однако не стоит так же сбрасывать со счетов и новый вариант. Кроме ленты новостей (RSS), "Welcome Page" содержит немало полезных ссылок. Во-первых, в самом верху страницы перечислен список проектов, которые вы уже открывали некоторое время назад, с указанием даты последней модификации. Каждая ссылка, естественно, открывает выбранный проект.

В левой части страницы подобраны ссылки на справочную информацию, документацию, которая устанавливается на ваш компьютер при инсталяции Delphi2005. Далее идут ссылки в интернет, на страницы компаний-разработчиков, чьи продукты встроены в среду. Например, на страницу Rave Reports, IntraWeb и так далее. И, наконец, ссылки на новостные группы в интернете, BDN и другие страницы Borland-ресурсов. То есть, "Welcome Page", действительно содержит полезную информацию. Может быть, не часто придется ею пользоваться, но и забывать о ней не стоит, может пригодиться.

Среда предоставляет возможнсть работать как в классическом стиле предыдущих версий Delphi (с отдельными окнами для дизайнера форм, инспектора объектов и т.д.), так и в стиле, максимально приближенном к MS Visual Studio, когда все окна пристыковываются к центральному, в котором можно заниматься дизайном формы или редактированием кода.

Для того, чтобы привести окна редактирования и палитры компонентов к привычному виду, поэкспериментируйте с настройками Tools | Environment Options | Delphi Options | VCL Designer | Embedded designer и Tools | Environment Options | Tool Pallete.

В Delphi2005 изменилась справочная система. Изменился не только внешний вид, но внутренняя структура предлагаемой информации. На мой взгляд, пользоваться справкой стало намного удобнее.

Появилась возможность настраивать цвета для Object Inspector, смотрите Tools | Environment Options | Object Inspector.

Начнем с одной приятной мелочи. Не знаю, как кому, но мне ее иногда очень не хватало в Delphi. Я имею в виду возможность быстро закомментировать или раскомментировать блок текста в редакторе.

В новой IDE это делается легким движением руки. Выделяем текст, нажимаем клавиши [Ctrl+/] и весь выделенный код оказался закомментирован. Обратная операция делается точно так же. На всякий случай напомню, почему это лучше, чем обычные скобки {} в начале и конце куска кода. В случае использования в начале каждой строки двойного слеша нет никакой нужды заботиться о вложенных комментариях, которые могут уже быть в выделенном тексте. Этот способ "устранения" части кода бывает удобен при отладке.

Очень удобна новая возможность редактора показывать соответствующие пары скобок (см. рисунок).

Как и в Delphi8, в редакторе Delphi2005 реализовано частичное скрытие (сворачивание кода). Это позволяет работать с большими текстами, не прокручивая многостраничный экран. Достаточно оставить развернутым сейчас только тот код, который используется. Для того чтобы свернуть или развернуть нужный блок, специально предусмотрены значки [-] и [+] в левой части редактора. Если нажать на значок [-], например, возле определения метода, код этого метода будет свернут, то есть, убран из видимости. Но, кроме этого, есть возможность применить эту операцию ко всему коду, а не только к текущему месту.

В меню по правой кнопке мыши есть два пункта Fold и UnFold. Это, соответственно, операции "свернуть" и "развернуть". Для каждой из них нужно указать место действия. Например, свернуть все методы в коде или все определения типов. Хочется заметить, что "свернутая" часть кода никуда не девается, а лишь уходит из видимой части редактора. Так что, если при компиляции или во время работы "Error Insight", ошибка окажется в свернутом коде, он прекрасным образом будет развернут автоматически в нужном месте. Так что никакой путаницы не возникнет.

Кроме этих возможностей, введены две директивы, которые по синтаксису аналогичны директивам компилятора, но оказывают влияние на поведение редактора, а не на генерируемый код. Это директивы $REGION и $ENDREGION. Они задают начало и конец сворачиваемого региона кода. Можно задать имя региона, в этом случае, когда регион свернут, вместо многоточия отображается имя региона.

Если в привычном "Code Insight" показывался тип идентификатора (переменной, функции и т.д.) и модуль, в котором он определен, то "Help Insight" представляет собой всплывающее окно-подсказку, с кратким описанием этого идентификатора и дополнительными ссылками (см. рис). Достаточно подвести мышку к нужному идентификатору, чтобы получить такой "маленький help". Использовать "Help Insight" можно в комбинации с "Code Completion". Если в окне "Code Completion" выбрать определенное свойство или метод, то справа появится окно с подсказкой.

Эта возможность реализована не только для стандартных, но и для собственных классов и переменных. Использование "Help Insight" включено по умолчанию. Местонахождение в настройках: Tools->Options->Editor Options->Code Insight

В левой части экрана есть окно "Structure". Оно используется для показа визуальных компонент, лежащих на форме, переменных и констант, списка модулей, которые подключены и так далее. Но, кроме этого окно "Structure" может показывать список синтаксических ошибок, которые определяются до момента компиляции с помощью "Error Insight".

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

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

Суть режима "Sync Edit" в том, что он позволяет показать в выделенном тексте все повторяющиеся идентификаторы, их может оказаться несколько групп. Самая первая считается текущей.

Для текущей группы все дубли помечены рамочкой, для остальных групп просто подчеркнуты. Переход между группами повторяющихся идентификаторов осуществляется клавишей TAB. Если начать изменять текущий идентификатор, то вслед за ним будут синхронно изменены все его дубли в этом выделенном блоке. Это похоже на "Рефакторинг: переименование идентификатора".

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

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

Повторное нажатие на иконку на левой полосе редактора кода, выключает "Sync Edit" и возвращает обычный режим редактирования.

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

Русские буквы в комментариях к коду

Поначалу неприятно удивило открытие файлов кода с комментариями в заголовке, написанными русскими буквами в кодировке Win1251. Часть таких файлов открываются, как двоичные. После небольшого исследования оказалось, что портит все маленькая буква "я" в тексте комментариев в начале модуля. Если в новой среде написать такой комментарий в начале модуля, то он редактируется нормально. Но, если его закрыть, то вновь откроется он в двоичном виде. По-видимому, проблема связана с тем, что редактор кода по первой порции фиксированного объема определяет формат файла. Встречая в этой порции букву "я" (ее код $FF), редактор некорректно определяет формат файла. При переносе текста с буквой "я" в конец файла или в середину файла большого размера, его формат определяется корректно.

Сходная ситуация обсуждалась в Подводных камнях.

Проблема с открытием таких файлов решается или удалением слов из заголовка модуля, содержащих маленькую букву "я", или замена ее на букву "Я" в верхнем регистре. Кому что нравится.

Русские буквы в названиях каталогов проекта

Проекты VCL.NET и WinForms не запускаются из-под среды, если в полном имени каталога проекта есть русские буквы. Среда сообщает "Unable to create process".

К сожалению, ссылки в окне "Help Insight" не будут работать, если у вас в названии каталогов используются русские буквы.

Рефакторинг "переименование символа" — при позиционировании курсора на нужном идентификаторе и выборе пункта меню Refactoring | Rename Field, среда показывает все строки, где встречается выбранный идентификатор, и предлагает выбрать новое имя. Очень удобная возможность, как тут не вспомнить Мартина Фаулера:

"Важной частью пропагандируемого мною стиля программирования является разложение сложных процедур на небольшие методы. Если делать это неправильно, то придется изрядно помучиться, выясняя, что же делают эти маленькие методы. Избежать таких мучений помогает назначение методам хороших имен. Методам следует давать имена, раскрывающие их назначение. Хороший способ для этого - представить себе, каким должен быть комментарий к методу, и преобразовать этот комментарий в имя метода. Жизнь такова, что удачное имя может не сразу придти в голову. В подобной ситуации может возникнуть соблазн бросить это занятие - в конце концов, не в имени счастье. Это вас соблазняет бес, не слушайте его. Если вы видите, что у метода плохое имя, обязательно измените его. Помните, что ваш код в первую очередь предназначен человеку, а только потом - компьютеру. Человеку нужны хорошие имена. Вспомните, сколько времени вы потратили, пытаясь что-то сделать, и насколько проще было бы, окажись у пары методов более удачные имена. Создание хороших имен - это мастерство, требующее практики; совершенствование этого мастерства - ключ к превращению в действительно искусного программиста. То же справедливо и в отношении других элементов сигнатуры метода. Если переупорядочивание параметров проясняет суть - выполните его."

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

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

Рефакторинг: процесс выделения метода

После выделения метода

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

Delphi 2005 располагает встроенными средствами для организации тестирования работы отдельных модулей программы, основанными на известных open-source проектах DUnit и NUnit (.NET). Среда позволяет создать проект-оболочку для тестов и шаблоны тестирующих модулей. Рассмотрим возможности Delphi 2005 на примере тестирования простого класса, осуществляющего перевод чисел из двоичной формы в символьную по заданному основанию системы счисления и, наоборот, из символьной в двоичную.

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

Реализация метода ToString будет содержать ошибки, которые мы будем обнаруживать тестированием. Первая реализация выглядит так:

unit Convertor; interface type TNumericConvertor = class private FBase: Integer; public constructor Create (const ABase: Integer); property Base: Integer read FBase; function ToString (const Value: Integer): string; function ToNumber (const Value: string): Integer; end; implementation { TNumericConvertor } constructor TNumericConvertor.Create(const ABase: Integer); begin Assert ((ABase > 1) and (ABase <= 36), 'Illegal Base specfied'); FBase := ABase; end; function TNumericConvertor.ToNumber(const Value: string): Integer; var I, Digit: Integer; begin Result := 0; for I:=1 to Length(Value) do begin if Value[I] > '9' then Digit := Ord(Value[I]) - Ord('A') + 10 else Digit := Ord(Value[I]) - Ord('0'); Assert ((Digit >= 0) and (Digit < Fbase), 'Illegal character'); Result := Result * FBase + Digit; end; end; function TNumericConvertor.ToString(const Value: Integer): string; var Rem, Quot: Integer; begin Assert (Value >= 0, 'Only positive numbers can be converted'); Result := ''; Quot := Value; while Quot <> 0 do begin Rem := Quot mod FBase; if Rem >= 10 then Result := Result + Char(Rem + Ord('0')) else Result := Result + Char(Rem + Ord('A') - 10); Quot := Quot div Fbase; end; if Result = '' then Result := '0'; end; end.

Добавим в эту оболочку первый тестирующий модуль командой File|New|Other выбрав в категории Unit Tests элемент Test Case.

• Добавление первого модуля, шаг 1
• Добавление первого модуля, шаг 2

В результате этих действий в IDE открывается окно с кодом сгенерированного класса для тестирования методов выбранного класса.

unit TestConvertor; { Delphi DUnit Test Case ---------------------- This unit contains a skeleton test case class generated by the Test Case Wizard. Modify the generated code to correctly setup and call the methods from the unit being tested. } interface uses TestFramework, Convertor; type // Test methods for class TNumericConvertor TestTNumericConvertor = class(TTestCase) strict private FNumericConvertor: TNumericConvertor; public procedure SetUp; override; procedure TearDown; override; published procedure TestToString; procedure TestToNumber; end; implementation procedure TestTNumericConvertor.SetUp; begin FNumericConvertor := TNumericConvertor.Create; end; procedure TestTNumericConvertor.TearDown; begin FNumericConvertor.Free; FNumericConvertor := nil; end; procedure TestTNumericConvertor.TestToString; var ReturnValue: string; Value: Integer; begin // TODO: Setup method call parameters ReturnValue := FNumericConvertor.ToString(Value); // TODO: Validate method results end; procedure TestTNumericConvertor.TestToNumber; var ReturnValue: Integer; Value: string; begin // TODO: Setup method call parameters ReturnValue := FNumericConvertor.ToNumber(Value); // TODO: Validate method results end; initialization // Register any test cases with the test runner RegisterTest(TestTNumericConvertor.Suite); end.

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

procedure TestTNumericConvertor.SetUp; begin FNumericConvertor := TNumericConvertor.Create (10); end;

procedure TestTNumericConvertor.TestToString; var ReturnValue: string; Value: Integer; begin Value := 10; ReturnValue := FNumericConvertor.ToString(Value); Assert (ReturnValue = '10', 'Expect ''10'', receive '''+ReturnValue+''''); end;

procedure TestTNumericConvertor.TestToNumber; var ReturnValue: Integer; Value: string; begin Value := '10'; ReturnValue := FNumericConvertor.ToNumber(Value); Assert (Returnvalue = 10, 'Expect 10, receive '+IntToStr(ReturnValue)); end;

После запуска тестов видно, что один из методов исходного класса работает некорректно, так как полученный результат не соответствует ожидаемому (Ожидается '10' получен 'AB')

Анализируя исходный код метода, видно, что при переводе очередного знака числа, условия then и else необходимо поменять местами:

if Rem >= 10 then Result := Result + Char(Rem + Ord('A') - 10) else Result := Result + Char(Rem + Ord('0'));

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

if Rem >= 10 then Result := Char(Rem + Ord('A') - 10) + Result else Result := Char(Rem + Ord('0')) + Result;

Снова компилируем тестовый проект, после запуска убеждаемся, что исправленный метод теперь работает как ожидалось, при заданных в тесте условиях.

Это не окончательный показатель гарантии правильной работы методов класса, для полной проверки необходим еще ряд тестов, тем не менее, две ошибки выявлены тестами за короткое время.

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

unit TestConvertor1; { Delphi DUnit Test Case ---------------------- This unit contains a skeleton test case class generated by the Test Case Wizard Modify the generated code to correctly setup and call the methods from the unit being tested. } interface uses TestFramework, Convertor; type // Test methods for class TNumericConvertor TestTNumericConvertor1 = class(TTestCase) strict private FNumericConvertor: TNumericConvertor; public procedure SetUp; override; procedure TearDown; override; published procedure TestToString; procedure TestToNumber; end; implementation uses SysUtils; procedure TestTNumericConvertor1.SetUp; begin FNumericConvertor := TNumericConvertor.Create(2); end; procedure TestTNumericConvertor1.TearDown; begin FNumericConvertor.Free; FNumericConvertor := nil; end; procedure TestTNumericConvertor1.TestToString; var ReturnValue: string; Value: Integer; begin Value := 11; ReturnValue := FNumericConvertor.ToString(Value); Assert(ReturnValue = '1011', 'Expect ''1011'', receive '''+ReturnValue+''''); end; procedure TestTNumericConvertor1.TestToNumber; var ReturnValue: Integer; Value: string; begin Value := '1011'; ReturnValue := FNumericConvertor.ToNumber(Value); Assert(ReturnValue = 11, 'Expect 11, receive '+IntToStr(ReturnValue)); end; initialization // Register any test cases with the test runner RegisterTest(TestTNumericConvertor1.Suite); end.

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

В заключение хочется добавить, что использовать unit-тесты можно было и раньше. Например, полтора года назад, одним из авторов обзора была разработана среда подобного рода для того, чтобы полностью осознать, что же такое unit-тесты. Среда включала в себя главную программу и эксперт для генерации тестирующих модулей. Разумеется, не с таким красивым и удобным интерфейсом, гораздо больше кода приходилось писать вручную, но главный итог такой разработки и использования — осознание необходимости тестирования, в особенности, использования unit-тестов как значительного подспорья для разработки программ.
Спасибо фирме Borland, что такие нужны и удобные средства уже встроены в их новый продукт — Delphi 2005.

В язык Delphi добавлена конструкция for..in..do для перебора всех членов массива, строки, множества или коллекции.

• for Element in ArrayExpr do Stmt;
• for Element in StringExpr do Stmt;
• for Element in SetExpr do Stmt;
• for Element in CollectionExpr do Stmt;

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

Полная и весьма понятная информация находится в справке, смотрите раздел "Declarations and Statements"

Наиболее интересным применением циклов такого вида является их использование с коллекциями для перебора элементов. Для того, чтобы класс можно было использовать с циклами for..in, класс должен реализовать предопределенный паттерн коллекции. А именно, класс должен удовлетворять следующим требованиям:

• содержать public метод экземпляра с именем GetEnumerator, который должен возвращать экземпляр класса, ссылку на интерфейс или запись (record).
• экземпляр класса, ссылка на интерфейс или запись, возвращенные методом GetEnumerator, должны содержать public метод экземпляра с именем MoveNext, возвращающий значение типа boolean.
• экземпляр класса, ссылка на интерфейс или запись, возвращенные методом GetEnumerator должны содержать public свойство экземпляра с именем Current, тип которого должен соответствовать типу элементов контейнера.

Экземпляр, возвращенный методом GetEnumerator, автоматически разрушается после окончания цикла for..in.

program Project1; {$APPTYPE CONSOLE} type TMyIntArray = array of Integer; TMyEnumerator = class Values: TMyIntArray; Index: Integer; public constructor Create; function GetCurrent: Integer; function MoveNext: Boolean; property Current: Integer read GetCurrent; end; TMyContainer = class public function GetEnumerator: TMyEnumerator; end; constructor TMyEnumerator.Create; begin inherited Create; Values := TMyIntArray.Create(100, 200, 300); Index := -1; end; function TMyEnumerator.MoveNext: Boolean; begin if Index < High(Values) then begin Inc(Index); Result := True; end else Result := False; end; function TMyEnumerator.GetCurrent: Integer; begin Result := Values[Index]; end; function TMyContainer.GetEnumerator: TMyEnumerator; begin Result := TMyEnumerator.Create; end; var MyContainer: TMyContainer; I: Integer; Counter: Integer; ar: TMyIntArray; begin MyContainer := TMyContainer.Create; Counter := 0; for I in MyContainer do Inc(Counter, I); WriteLn('Counter = ', Counter); end.

Поддержка синтаксиса for...in уже встроена в ряд классов VCL, например, TList, TComponent, TCollection, и т.д. - в общей сложности около 15 классов. Так, например, перечисление имен компонентов формы может выглядеть следующим образом (хотя и непривычно):

var I: TComponent; begin for I in Self do ListBox.Add (I.Name); end;

Для большей совместимости исходного кода с Delphi for .NET введены два новых модификатора области видимости членов класса.

strict private

Члены класса с видимостью strict private доступны только самому классу.

strict protected

Члены класса с видимостью strict protected доступны только самому классу и его непосредственным наследникам.

Отличие новых модификаторов от традиционных private и protected заключается в том, что члены с новыми модификаторами не доступны постороннему коду, находящемуся в том же модуле.

Раньше, хотя компилятор и позволял использовать методы класса в качестве аксессоров свойств, обращение к таким свойствам в форме TSomeClass.PropName было невозможно. Теперь, с введением свойств класса такое обращение разрешено. Однако, в отличие от Delphi for .NET, свойства класса могут работать только через методы, т.к. понятие полей класса для компилятора Delphi for Win32 отсутствует.

type TTestClass = class class function GetClassProp: integer; class procedure SetClassProp(value: integer); class property ClassProp: integer read GetClassProp write SetClassProp; end; TestClass.ClassProp := ...;

Эта возможность также является новшеством только для компилятора Delphi for Win32. Теперь, как и в случае с Delphi for .NET, можно объявлять типы данных и константы внутри других классов.

type TOuterClass = class public const x = 12; i: integer = 1; type TInnerClass = class public myInnerField: Integer; procedure innerProc; end; procedure outerProc; end;

Обращение ко вложенным типам и константам производится через имя типа, в который они вложены, например, TOuterClass.TInnerClass или TOuterClass.x. Для вложенных типов и констант действуют те же модификаторы видимости, что и для остальных членов классов.

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

Если по каким-то причинам разработчик хочет запретить создание наследников класса, это можно сделать используя модификатор sealed.

type TMyFinalClass = class sealed(TObject) end;

Так же, в язык добавлено ключевое слово final для вирутальных и динамических методов, запрещающее их дальнейшее перекрытие. Эта возможность присутствует как в компиляторе .NET, так и в компиляторе для Win32

type TClass1 = class private .... public constructor Create; destructor Destroy; override; final; .... end; TClass2 = class(TClass1) .... public destructor Destroy; override; end;

Для компилятора Delphi for .NET эта возможность существует с версии Delphi 8. Теперь эта возможность доступна и в компиляторе для Win32. Компилятор умеет различать в исходном тексте специальным образом оформленные комментарии и генерировать на их основе XML файлы. Формат комментариев во многом похож на XML. Каждый комментарий, который будет анализироваться на наличие тегов XML документации предшествовует документируемому объекту и должен начинаться с комбинации из трёх символов "/". Существует набор тегов, которые рекомендуется применять при оформлении комментариев. Он описан в справке .NET SDK. К сожалению для тех, кто не любит писать всякие теги руками, IDE никак не облегчает оформление таких комментариев.

type /// Test comment /// TForm3 = class(TForm) private { Private declarations } /// Test comment 1 /// procedure Test; public { Public declarations } end;

1.0" encoding="utf-8"?> <class name="TForm3"> Test comment public" /> public" /> здесь перечисляются предки и все их члены <procedure name="Test" visibility="private"> Test comment 1 procedure> class> type="TForm3" />

В новой версии компилятора Delphi появилась возможность использования inline кода. Для этого наполнена новым смыслом директива inline. Теперь, если процедура или функция имеют директиву inline, это заставит компилятор попытаться вставить в место, где эта процедура используется, не вызов, а код тела процедуры. Само наличие директивы inline ещё не гарантирует того, что попытка будет удачной. Существуют определенные ограничения. Согласно справочной системе, эти ограничения таковы:

• inline не работает для любых видов методов позднего связывания (virtual, dynamic, message)
• inline не работает для процедур содержащих код на языке ассемблера,
• inline не работает для конструкторов и деструкторов
• inline не работает для главного блока программы и секций инициализации и финализации модулей
• inline код может быть использован внутри пакетов, но inline не работает через границы пакетов
• inline не работает в модулях, связанных кольцевой зависимостью. Это ограничение включает и неявные кольцевые ссылки между модулями. Например, если модуль A использует модуль B, модуль B использует C, а C, в свою очередь, использует A, то при компиляции модуля A не будет производиться inline-подстановка кода из модулей B и C.
• inline-подстановка в модулях, входящих в кольцевые зависимости, может быть произведена, если подстановка производится из модуля, не входящего в кольцо зависимостей. Например, если в предыдущем примере модуль A использует также модуль D, то в модуле A возможна inline-подстановка кода из модуля D.
• inline не работает, если процедура объявлена в секции interface модуля и обращается к символам, объявленным в секции implementation.
• inline не работает для методов в классах, если они обращаются к членам классов, имеющим более низкую видимость, чем сам метод. Например, если public метод обращается к private методу, то для такого метода inline-подстановка осуществляться не будет.
• если процедура, помеченная как inline использует процедуры или переменные из внешних модулей, то все эти модули должны быть перечислены в списке uses того модуля, где inline процедура будет использована, иначе inline-подстановка не производится.
• inline-подстановка не осуществляется для процедур и функций, которые используются в выражениях проверки условия циклов while и repeat.

При использовании inline процедур следует помнить о том, что изменение кода такой процедуры приведет к перекомпиляции всех модулей, где она используется.

• {$INLINE ON} - Процедуры, с директивой inline будут помечены, как процедуры, для которых возможна inline-подстановка. При вызове таких процедур будет сделана попытка inline подстановки кода. Действует по умолчанию.
• {$INLINE AUTO} - Процедуры, с директивой inline будут помечены, как процедуры, для которых возможна inline-подстановка только в том случае, если код процедуры будет размером меньше 32 байт.
• {$INLINE OFF} - Процедуры, не смотря на наличие директивы inline, никогда не будут помечены, как процедуры, для которых возможна inline-подстановка. При вызове процедур попытка inline подстановки кода не будет сделана.

Для компилятора Delphi for .NET добавлена возможность включения небезопасного кода в приложения .NET. Для этого введена локальная директива компилятора {$UNSAFECODE}, которая может принимать значения ON и OFF а также добавлено ключевое слово unsafe, которое применяется к процедурам и функциям. Приложения, использующие небезопасный код не проходит проверку при помощи утилиты PEVerify. Подробнее о небезопасном коде смотрите в документации .NET SDK.

procedure unsafeProc; unsafe; begin end;

type Работник = record Фамилия: string; Имя: string; Отчество: string; ДатаРождения: TdateTime; Должность: string; end;

Rabotnik = record Familija: string; Imya: string; Ochestvo: string; DataRogdenija: TdateTime; Dolgjnost: string; end;

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

type Целое = Integer; procedure TfMain.BtnCountClick(Sender: TObject); var Счетчик: Целое; begin for Счетчик:=0 to 5 do begin btnCount.Caption := IntToStr(Счетчик); Sleep(500); Application.ProcessMessages; end; end;

Delphi для Win32

Теперь можно делать задание размеров массива и инициализацию одной строкой

type
  TMyIntArray = array of Integer;

var
  Ints: TMyIntArray;

begin
  Ints := TMyIntArray.Create(1,2,3,4,5);

Delphi for .NET

Новый расширенный синтаксис позволяет объявлять массивы в форме

array[, ..., ] of baseType;

Также возможна инициализация массивов при помощи стандартной процедуры new.

var
  a: array [,,] of integer;  // 3 dimensional array
  b: array [,] of integer;   // 2 dimensional array
  c: array [,] of TPoint;    // 2 dimensional array of TPoint

begin
  // New taking element type and size of each dimension.
  a := New(array[3,5,7] of integer);
  // New taking the element type and initializer list.
  b := New(array[,] of integer, ((1,2,3), (4,5,6)));
  // New taking an initializer list of TPoint.
  c := New(array[,] of TPoint, (((X:1;Y:2), (X:3;Y:4)), ((X:5;Y:6), (X:7;Y:8))));
end.

Понравилось поведение системы при возникновении Exception — появляется окно с уведомлением об Exception и с возможностью поставить галочку "Игнорировать этот тип Exception", вместо того, чтобы открывать окно Tools | Debugger..

Изменилась работа с точками останова. Появилась очень удобная возможность, не удаляя точку останова, отключить ее, пометив как "disable". Это можно сделать в редакторе кода по правой кнопке на точке останова, и прямо в списке "Breakpoint list". В этом списке можно включать/выключать все точки или определенные группы (меню по правой кнопке). Так же, теперь прямо в окне "Breakpoint list" можно изменять значение Condition и принадлежность к определенной группе для каждой точки.

В IDE интегрирован Data Explorer, который содержит как средства просмотра базы данных, так и ряд инструментов для редактирования. Окно Data Explorer можно найти на одной из закладок окна Project Manager справа от редактора кода (при умолчанных настройках среды) или в меню View | Data Explorer

Просмотр данных

Это операция по умолчанию — двойной клик по имени таблицы в списке. Открывается отдельное окно с содержимым таблицы. Возможно редактировать все поля, даже identity и computed column. Диагностика производится в момент сохранения изменений (правая кнопка мыши | Update/Rollback), так что испортить таблицу затруднительно.

Изменение структуры

Визуальный аналог команды "Alter table".

В этом окне по правой кнопке мыши доступны команды Save changes/Show DDL/ Exeсute DDL
DDL (Data definition language) — текст SQL-скрипта, который отражает сделанные визуально изменения в структуре таблицы.

Удаление таблицы

Выполнение команды "Drop table"

Копирование таблицы

Копирование существующей таблицы в новую. Происходит, как создание новой таблицы с такой же структурой (имя новой таблицы запрашивается при выполнении paste) и заполнении ее данным из копируемой таблицы.

Доступные операции Refresh/View Parameters. Окно просмотра параметров открывается при двойном клике на имени процедуры. В этом окне можно указать значения всех входных параметров и, выполнив процедуру, получить заполненные значениями выходные параметры (см. рис). Для выполнения процедуры можно воспользоваться иконкой в верхнем левом углу окна или по правой кнопке мыши (команда Execute).

Если хранимая процедура в качестве результата возвращает еще и (или только) набор данных, необходимо поставить галочку "Stored procedure has one or more cursors" и выполнить процедуру снова.

• Окно с настройкой параметров процедуры и получением результатов
• Результат работы хранимой процедуры, которая возвращает набор данных

Безусловно, новые возможности для тестирования работы хранимых процедур очень удобны и позволят упростить жизнь разработчика баз данных.

В качестве недостатка можно отметить отсутствие возможности прервать выполнение хранимой процедуры, если время выполнения оказывается довольно продолжительным.

Это привычное окно для выполнения SQL-запросов. Так как тестирование проходило только для MS SQL Server, то возможно, некоторые странности связаны с конкретным драйвером.

Сами SQL-запросы любой сложности (UNION, вложенные подзапросы и т.п.) выполняются без проблем. Странности начались после попытки исполнить в этом окне процедуру ("execute имя_процедуры"), которая в качестве результата возвращает набор данных. В качестве результата было получено сообщение "-1 row(s) affected". И этот результат был одинаков для всех процедур одного сервера. Тест на другом сервере дал иной результат, возможно этот эффект зависит от настроек на сервере (или от настроек конкретной базы), но такого иследования не проводилось. Итак, на другом сервере после выполнения процедуры было получено окошко с сообщением, например, таким: "192 row(s) affected", что само по себе верно, но никакого результата, то есть набора данных, все равно не было выведено. Если в тексте процедуры был оператор "Insert Into имя_таблицы exec имя_процедуры", то в качестве количества обработанных строк в результирующем сообщении выдавалось количество строк этого insert'а, а вовсе не последнего select'а процедуры.

Можно предположить, что проблема кроется в ADO.NET, на котором реализован Data Explorer.

И, все же, несмотря на это, Data Explorer добавляет в среду разработки функционал, который реально может облегчить жизнь разработчику клиентских приложений для баз данных.

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

Спасибо компании Borland за возможность ознакомиться с новой версией, которая несомненно, позволит вывести разработку приложений на качественно новый этап.

• Пример для раздела "Unit-тестирование" (565.5 K) обновление от 12/1/2004 12:48:00 PM