Сообщений 19 
Оценка 112 
Оценить 
| Сообщений 19 Оценка 112 Оценить
|
При программировании нередко возникает необходимость выполнить обращение к объекту, находящемуся в другом загрузочном модуле, например EXE или DLL. Для решения поставленной задачи компания Microsoft разработала технологию COM (Component Object Model) — компонентную модель объектов. Технология получила такое название благодаря тому, что обеспечивает создание программных компонентов — независимо разрабатываемых и поставляемых двоичных модулей. Поскольку объекты различных программ разрабатываются на различных языках программирования, например Delphi, C++, Visual Basic и др., технология COM стандартизирует формат взаимодействия между объектами на уровне двоичного представления в оперативной памяти. Согласно технологии COM взаимодействие между объектами осуществляется посредством так называемых интерфейсов. Рассмотрим, что же они собой представляют и как с ними работают.
Из предыдущих глав вы уже знаете, что собой представляет объект. Представьте, что получится, если из объекта убрать поля и код всех методов. Останется лишь интерфейс — заголовки методов и описания свойств. Схематично понятие интерфейса можно представить в виде формулы:
Интерфейс = Объект – Реализация
В отличие от объекта интерфейс сам ничего “не помнит” и ничего “не умеет делать”; он является всего лишь "разъемом" для работы с объектом. Объект может поддерживать много интерфейсов и выступать в разных ролях в зависимости от того, через какой интерфейс вы его используете. Совершенно различные по структуре объекты, поддерживающие один и тот же интерфейс, являются взаимозаменяемыми. Не важно, есть у объектов общий предок или нет. В данном случае интерфейс служит их дополнительным общим предком.
В языке Delphi интерфейсы описываются в секции type глобального блока. Описание начинается с ключевого слова interface и заканчивается ключевым словом end. По форме объявления интерфейсы похожи на обычные классы, но в отличие от классов:
Приведем пример интерфейса и сразу заметим, что интерфейсам принято давать имена, начинающиеся с буквы I (от англ. Interface):
type
ITextReader = interface// Методыfunction NextLine: Boolean;
// Свойстваproperty Active: Boolean;
property ItemCount: Integer;
property Items[Index: Integer]: string;
property EndOfFile: Boolean;
end;
|
Интерфейс ITextReader предназначен для считывания табличных данных из текстовых источников. В главе 3 мы уже создавали объекты, которые умеют это делать, поэтому назначение методов и свойств должно быть вам понятно. Непонятно пока другое — зачем вообще нужен интерфейс для доступа к табличным данным, если уже есть готовый класс TTextReader с требуемой функциональностью.
Объяснение состоит в следующем. Не определив интерфейс ITextReader, невозможно разместить класс TTextReader в DLL-библиотеке и обеспечить доступ к нему из EXE-программы. Создавая DLL-библиотеку, мы с помощью оператора uses должны включить модуль ReadersUnit в проект библиотеки. Создавая EXE-программу, мы должны включить модуль ReadersUnit и в нее, чтобы воспользоваться описанием класса TTextReader. Но тогда весь программный код класса попадет внутрь EXE-файла, а это именно то, от чего мы хотим избавиться. Решение проблемы обеспечивается введением понятия интерфейса.
Чтобы вам было легче разобраться с интерфейсом ITextReader, мы привели его незаконченный вариант. Компиляция интерфейса в таком виде приведет к ошибкам: для свойств не указаны методы чтения и записи. Полное описание интерфейса выглядит так:
type
ITextReader = interface// Методыfunction NextLine: Boolean;
procedure SetActive(const Active: Boolean);
function GetActive: Boolean;
function GetItemCount: Integer;
function GetItem(Index: Integer): string;
function GetEndOfFile: Boolean;
// Свойстваproperty Active: Boolean read GetActive write SetActive;
property Items[Index: Integer]: string read GetItem; default;
property ItemCount: Integer read GetItemCount;
property EndOfFile: Boolean read GetEndOfFile;
end;
|
Поскольку интерфейс не может содержать поля, все его свойства отображены на его методы.
Новый интерфейс можно создать с нуля, а можно создать путем расширения уже существующего интерфейса. Во втором случае в описании интерфейса после слова interface указывается имя базового интерфейса:
type
IExtendedTextReader = interface(ITextReader)
procedure SkipLines(Count: Integer);
end;
|
Определенный таким образом интерфейс включает все методы и свойства своего предшественника и добавляет к ним свои собственные. Несмотря на синтаксическое сходство с наследованием классов, расширение интерфейсов имеет другой смысл. В классах наследуется реализация, а в интерфейсах просто расширяется набор методов и свойств.
В языке Delphi существует предопределенный интерфейс IInterface, который служит неявным базовым интерфейсом для всех остальных интерфейсов. Это означает, что объявление
type
ITextReader = interface
...
end;
|
эквивалентно следующему:
type
ITextReader = interface(IInterface)
...
end;
|
Мы рекомендуем использовать вторую, более полную форму записи.
Описание интерфейса IInterface находится в стандартном модуле System:
type
IInterface = interface
['{00000000-0000-0000-C000-000000000046}']
function QueryInterface(const IID: TGUID; out Obj): HResult; stdcall;
function _AddRef: Integer; stdcall;
function _Release: Integer; stdcall;
end;
|
Непонятная последовательность нулей и других цифр в квадратных скобках — это так называемый глобально-уникальный идентификатор интерфейса. Мы к нему еще вернемся, а сейчас рассмотрим методы.
Методы интерфейса IInterface явно или неявно попадают во все интерфейсы и имеют особое назначение. Метод QueryInterface нужен для того, чтобы, имея некоторый интерфейс, запросить у объекта другой интерфейс. Этот метод автоматически вызывается при преобразовании одних интерфейсов в другие. Метод _AddRef автоматически вызывается при присваивании значения интерфейсной переменной. Метод _Release автоматически вызывается при уничтожении интерфейсной переменной. Последние два метода позволяют организовать подсчет ссылок на объект и автоматическое уничтожение объекта, когда количество ссылок на него становится равным нулю. Вызовы всех трех методов генерируются компилятором автоматически, и вызывать их явно нет необходимости, однако программист должен позаботиться об их реализации.
Интерфейс является особым типом данных: он может быть реализован в одной программе, а использоваться из другой. Для этого нужно обеспечить идентификацию интерфейса при межпрограммном взаимодействии. Понятно, что программный идентификатор интерфейса для этого не подходит — разные программы пишутся разными людьми, а разные люди подчас дают одинаковые имена своим творениям. Поэтому каждому интерфейсу выдается своеобразный «паспорт» — глобально-уникальный идентификатор (Globally Unique Identifier — GUID).
Глобально-уникальный идентификатор — это 16-ти байтовое число, представленное в виде заключенной в фигурные скобки последовательности шестнадцатеричных цифр:
{DC601962-28E5-4BF7-9583-0CE22B605045}
|
В среде Delphi глобально-уникальный идентификатор описывается типом данных TGUID:
type
PGUID = ^TGUID;
TGUID = packedrecord
D1: Longword;
D2: Word;
D3: Word;
D4: array[0..7] of Byte;
end;
|
Константы с типом TGUID разрешено инициализировать строковым представлением глобально-уникального идентификатора. Компилятор сам преобразует строку в запись с типом TGUID. Пример:
const
InterfaceID: TGUID = '{DC601962-28E5-4BF7-9583-0CE22B605045}';
|
Если глобально-уникальный идентификатор назначается интерфейсу, то он записывается после ключевого слова interface и заключается в квадратные скобки, например:
type
IInterface = interface
['{00000000-0000-0000-C000-000000000046}']
...
end;
|
В будущем нашему интерфейсу ITextReader понадобится глобально-уникальный идентификатор. Но как его выбрать так, чтобы он оказался уникальным? Очень просто — нажмите в редакторе кода комбинацию клавиш Ctrl+Shift+G.
type
ITextReader = interface
['{DC601962-28E5-4BF7-9583-0CE22B605045}'] // Результат нажатия Ctrl+Shift+G
...
end;
|
Генерация глобально-уникальных идентификаторов осуществляется системой Windows по специальному алгоритму, в котором задействуется адрес сетевого адаптера, текущее время и генератор случайных чисел. Можете смело полагаться на уникальность всех получаемых идентификаторов.
Наличие глобально-уникального идентификатора в описании интерфейса не является обязательным, однако использование интерфейса без такого идентификатора ограничено, например, запрещено использовать оператор as для преобразования одних интерфейсов в другие.
Если у интерфейса есть глобально-уникальный идентификатор, то программный идентификатор интерфейса можно использовать там, где ожидается тип данных TGUID, например:
const
IID_ITextReader: TGUID = '{DC601962-28E5-4BF7-9583-0CE22B605045}';
function TestInterface(const IID: TGUID): Boolean;
begin
...
TestInterface(ITextReader);
// эквивалентно
TestInterface(IID_ITextReader);
...
end;
|
Интерфейс бесполезен до тех пор, пока он не реализован. Реализацией интерфейса занимается класс. Если класс реализует интерфейс, то интерфейс может использоваться для доступа к объектам этого класса. При объявлении класса имя реализуемого интерфейса записывается через запятую после имени базового класса:
type
TTextReader = class(TObject, ITextReader)
...
end;
|
Такая запись означает, что класс TTextReader унаследован от класса TObject и реализует интерфейс ITextReader (см. рисунок 6.1).
Рисунок 6.1. Класс TTextReader унаследован от класса TObject и реализует интерфейс ITextReader. Сплошными линиями отмечено наследование классов, а пунктирной линией — реализация интерфейса классом.
Класс, реализующий интерфейс, должен содержать код для всех методов интерфейса. Класс TTextReader в модуле ReadersUnit (см. главу 3) вроде бы содержит код для всех методов интерфейса ITextReader, и все, что нужно сделать, — это добавить имя интерфейса в заголовок класса. Сделайте это в модуле ReadersUnit:
unit ReadersUnit;
interfacetype
ITextReader = interface
...
end;
TTextReader = class(TObject, ITextReader)
...
end;
|
Если класс содержит только часть методов интерфейса, то недостающие методы придется добавить. Так в интерфейсе ITextReader описан метод GetActive, а в классе TTextReader такого метода нет. Добавьте метод GetActive в класс TTextReader:
type
TTextReader = class(TObject, ITextReader)
...
function GetActive: Boolean;
...
end;
function TTextReader.GetActive: Boolean;
begin
Result := FActive;
end;
|
Но это еще не все. Мы совсем забыли о методах QueryInterface, _AddRef и _Release, которые тоже должны быть реализованы. К счастью, вам нет необходимости ломать голову над реализацией этих методов, поскольку разработчики системы Delphi уже позаботились об этом. Стандартная реализация методов интерфейса IInterface находится в классе TInterfacedObject. Мы его рассмотрим ниже, а сейчас просто унаследуем класс TTextReader от класса TInterfacedObject — и он получит готовую реализацию методов QueryInterface, _AddRef и _Release.
type
TTextReader = class(TInterfacedObject, ITextReader)
...
end;
|
Теперь реализация интерфейса ITextReader полностью завершена и можно переходить к использованию объектов класса TTextReader через этот интерфейс.
Для доступа к объекту через интерфейс нужна интерфейсная переменная:
var
Intf: ITextReader;
|
Интерфейсная переменная занимает в оперативной памяти четыре байта, хранит ссылку на интерфейс объекта и автоматически инициализируется значением nil.
Перед использованием интерфейсную переменную инициализируют значением объектной переменной:
var
Obj: TTextReader; // объектная переменная
Intf: ITextReader; // интерфейсная переменнаяbegin
...
Intf := Obj;
...
end;
|
После инициализации интерфейсную переменную Intf можно использовать для вызова методов объекта Obj:
Intf.Active := True; // -> Obj.SetActive(True); Intf.NextLine; // -> Obj.NextLine; |
Через интерфейсную переменную доступны только те методы и свойства объекта, которые есть в интерфейсе:
Intf.Free; // Ошибка! У интерфейса ITextReadaer нет метода Free. Obj.Free; // Метод Free можно вызвать только так. |
Один класс может содержать реализацию нескольких интерфейсов. Такая возможность позволяет воплотить в классе несколько понятий. Например, класс TTextReader — "считыватель табличных данных" — может выступить еще в одной роли — "считыватель строк". Для этого он должен реализовать интерфейс IStringIterator:
type
IStringIterator = interfacefunction Next: string;
function Finished: Boolean;
end;
|
Интерфейс IStringIterator предназначен для последовательного доступа к списку строк. Метод Next возвращает очередную строку из списка, метод Finished проверяет, достигнут ли конец списка.
Реализуем интерфейс IStringIterator в классе TTextReader таким образом, чтобы последовательно считывались значения из ячеек таблицы. Например, представьте, что в некотором файле дана таблица:
Aaa Bbb Ccc Ddd Eee Fff Ggg Hhh Iii |
Чтение этой таблицы через интерфейс IStringIterator вернет следующую последовательность строк:
Aaa Bbb Ccc Ddd Eee Fff Ggg Hhh Iii |
Ниже приведен программный код, обеспечивающий поддержку интерфейса IStringIterator в классе TTextReader:
type
TTextReader = class(TInterfacedObject, ITextReader, IStringIterator)
FColumnIndex: Integer;
function Next: string;
function Finished: Boolean;
...
end;
...
function TTextReader.Next: string;
beginif FColumnIndex = ItemCount then// Если пройден последний элемент текущей строки,begin// то переходим к следующей строке таблицы
NextLine;
FColumnIndex := 0;
end;
Result := Items[FColumnIndex];
FColumnIndex := FColumnIndex + 1;
end;
function TTextReader.Finished: string;
begin
Result := EndOfFile and (FColumnIndex = ItemCount);
end;
|
Теперь объекты класса TTextReader совместимы сразу с тремя типами данных: TInterfacedObject, ITextReader, IStringIterator.
var
Obj: TTextReader;
Reader: ITextReader;
Iterator: IStringIterator;
begin
...
Reader := Obj; // Правильно
Iterator := Obj; // Правильно
...
end;
|
В одном случае объект класса TTextReader рассматривается как считыватель табличных данных, а в другом случае — как обычный список строк с последовательным доступом. Например, если есть две процедуры:
procedure LoadTable(Reader: ITextReader);
procedure LoadStrings(Iterator: IStringIterator);
|
то объект класса TTextReader можно передать в обе процедуры:
LoadTable(Obj); // Obj воспринимается как ITextReader LoadStrings(Obj); // Obj воспринимается как IStringIterator |
Несколько совершенно разных классов могут содержать реализацию одного и того же интерфейса. С объектами таких классов можно работать так, будто у них есть общий базовый класс. Интерфейс выступает аналогом общего базового класса.
Рассмотрим пример. Представьте, что есть два класса: TTextReader и TIteratableStringList:
type
TTextReader = class(TInterfacedObject, ITextReader, IStringIterator)
...
end;
TIteratableStringList = class(TStringList, IStringIterator)
...
end;
|
Схематично полученную иерархию классов можно представить так (рисунок 6.2):
Рисунок 6.2. Иерархия классов, реализующих интерфейсы. Сплошными линиями отмечено наследование классов, а пунктирными линиями — реализация интерфейсов классами.
Объекты классов TTextReader и TIteratableStringList несовместимы между собой. Тем не менее, они совместимы с переменными типа IStringIterator. Это значит, что если есть процедура:
procedure LoadStrings(Iterator: IStringIterator);
|
то вы можете передавать ей объекты обоих упомянутых классов в качестве аргумента:
var
ReaderObj: TTextReader;
StringsObj: TIteratableStringList;
begin
...
LoadStrings(ReaderObj); // Все правильно
LoadStrings(StringsObj); // Все правильно
...
end;
|
Метод интерфейса связывается с методом класса по имени. Если имена по каким-то причинам не совпадают, то можно связать методы явно с помощью специальной конструкции языка Delphi.
Например, в классе TTextReader добавлены методы Next и Finished для поддержки интерфейса IStringIterator. Согласитесь, что существование в одном классе методов Next и NextLine вносит путаницу. По названию метода Next не понятно, что для этого метода является следующим элементом. Поэтому уточним название метода в классе TTextReader и воспользуемся явным связыванием методов, чтобы сохранить имя Next в интерфейсе IStringIterator:
type
TTextReader = class(TInterfacedObject, ITextReader, IStringIterator)
...
function NextItem: string;
function IStringIterator.Next := NextItem; // Явное связываниеend;
|
При работе с объектами класса TTextReader через интерфейс IStringIterator вызов метода Next приводит к вызову метода NextItem:
var
Obj: TTextReader;
Intf: IStringIterator;
begin
...
Intf := Obj;
Intf.Next; // -> Obj.NextItem;
...
end;
|
Очевидно, что связываемые методы должны совпадать по сигнатуре (списку параметров и типу возвращаемого значения).
Случается, что реализация интерфейса содержится во вложенном объекте класса. Тогда не требуется программировать реализацию интерфейса путем замыкания каждого метода интерфеса на соответствующий метод вложенного объекта. Достаточно делегировать реализацию интерфейса вложенному объекту с помощью директивы implements:
type
TTextParser = class(TInterfacedObject, ITextReader)
...
FTextReader: ITextReader;
property TextReader: ITextReader read FTextReader implements ITextReader;
...
end;
|
В этом примере интерфейс ITextReader в классе TTextParser реализуется не самим классом, а его внутренней переменной FTextReader.
Очевидно, что внутренний объект должен быть совместим с реализуемым интерфейсом.
Совместимость интерфейсов подчиняется определенным правилам. Если интерфейс создан расширением уже существующего интерфейса:
type
IExtendedTextReader = interface(ITextReader)
...
end;
|
то интерфейсной переменной базового типа может быть присвоено значение интерфейсной переменной производного типа:
var
Reader: ITextReader;
ExtReader: IExtendedTextReader;
begin
...
Reader := ExtReader; // Правильно
...
end;
|
Но не наоборот:
ExtReader := Reader; // Ошибка! |
Правило совместимости интерфейсов чаще всего применяется при передаче параметров в процедуры и функции. Например, если процедура работает с переменными типа ITextReader,
procedure LoadFrom(const R: ITextReader);
|
то ей можно передать переменную типа IExtendedTextReader:
LoadFrom(ExtReader); |
Заметим, что любая интерфейсная переменная совместима с типом данных IInterface — прародителем всех интерфейсов.
Интерфейсной переменной можно присвоить значение объектной переменной при условии, что объект (точнее его класс) реализует упомянутый интерфейс:
var
Intf: ITextReader; // интерфейсная переменная
Obj: TTextReader; // объектная переменнаяbegin
...
Intf := Obj; // В переменную Intf копируется ссылка на объект Obj
...
end;
|
Такая совместимость сохраняется в производных классах. Если класс реализует некоторый интерфейс, то и все его производные классы совместимы с этим интерфейсом (см. рисунок 6.3):
type
TTextReader = class(TInterfacedObject, ITextReader)
...
end;
TDelimitedReader = class(TTextReader)
...
end;
var
Intf: ITextReader; // интерфейсная переменная
Obj: TDelimitedReader; // объектная переменнаяbegin
...
Intf := Obj;
...
end;
|
Рисунок 6.3. Классы TTextReader, TDelimitedReader и TFixedReader совместимы с интерфейсом ITextReader
Однако, если класс реализует производный интерфейс, то это совсем не означает, что он совместим с базовым интерфейсом (см. рисунок 6.4):
type
ITextReader = interface(IInterface)
...
end;
IExtendedTextReader = interface(ITextReader)
...
end;
TExtendedTextReader = class(TInterfacedObject, IExtendedTextReader)
...
end;
var
Obj: TExtendedTextReader;
Intf: ITextReader;
begin
...
Intf := Obj; // Ошибка! Класс TExtendedTextReader не реализует// интерфейс ITextReader.
...
end;
|
Рисунок 6.4. Класс TExtendedTextReader совместим лишь с интерфейсом IExtendedTextReader
Для совместимости с базовым интерфейсом нужно реализовать этот интерфейс явно:
type
TExtendedTextReader = class(TInterfacedObject, ITextReader, IExtendedTextReader)
...
end;
|
Теперь класс TExtendedTextReader совместим и с интерфейсом ITextReader, поэтому следующее присваивание корректно:
Intf := Obj; |
Исключением из только что описанного правила является совместимость всех снабженных интерфейсами объектов с интерфейсом IInterface:
var
Obj: TExtendedTextReader;
Intf: IInterface;
begin
...
Intf := Obj; // Правильно, IInterface – особый интерфейс.
...
end;
|
Через интерфейсную переменную у объекта всегда можно запросить интерфейс другого типа. Для этого используется оператор as, например:
var
Intf: IInterface;
begin
...
with Intf as ITextReader do
Active := True;
...
end;
|
Если объект действительно поддерживает запрашиваемый интерфейс, то результатом является ссылка соответствующего типа. Если же объект не поддерживает интерфейс, то возникает исключительная ситуация EIntfCastError.
В действительности оператор as преобразуется компилятором в вызов метода QueryInterface:
var
Intf: IInterface;
IntfReader: ITextReader;
...
IntfReader := Intf as ITextReader; // Intf.QueryInterface(ITextReader, IntfReader); |
Напомним, что метод QueryInterface описан в интерфейсе IInterface и попадает автоматически во все интерфейсы. Стандартная реализация этого метода находится в классе TInterfacedObject.
Механизм подсчета ссылок на объект предназначен для автоматического уничтожения неиспользуемых объектов. Неиспользуемым считается объект, на который не ссылается ни одна интерфейсная переменная.
Подсчет ссылок на объект обеспечивают методы _AddRef и _Release интерфейса IInterface. При копировании значения интерфейсной переменной вызывается метод _AddRef, а при уничтожении интерфейсной переменной — метод _Release. Вызовы этих методов генерируются компилятором автоматически:
var
Intf, Copy: IInterface;
begin
...
Copy := Intf; // Copy._Release; Intf._AddRef;
Intf := nil; // Intf._Release; end; // Copy._Release |
Стандартная реализация методов _AddRef и _Release находится в классе TInterfacedObject. Она достаточно проста и вы легко разберетесь с ней, читая комментарии в исходном тексте.
type
TInterfacedObject = class(TObject, IInterface)
...
FRefCount: Integer; // Счетчик ссылокfunction _AddRef: Integer; stdcall;
function _Release: Integer; stdcall;
...
end;
function TInterfacedObject._AddRef: Integer;
begin
Result := InterlockedIncrement(FRefCount); // Увеличение счетчика ссылокend;
function TInterfacedObject._Release: Integer;
begin
Result := InterlockedDecrement(FRefCount); // Уменьшение счетчика ссылокif Result = 0 then// Если ссылок больше нет, то
Destroy; // уничтожение объектаend;
|
Заметим, что функции InterlockedIncrement и InterlockedDecrement просто увеличивают значение целочисленной переменной на единицу. В отличие от обычного оператора сложения, они обеспечивают атомарное изменение значения переменной, что очень важно для правильной работы распараллеленных (многопоточных) программ.
Приведенную выше реализацию методов _AddRef и _Release автоматически получают все наследники класса TInterfacedObject, в том числе и классы TTextReader, TDelimitedReader и TFixedReader. Поэтому неиспользуемые объекты классов TDelimitedReader и TFixedReader тоже автоматически уничтожаются при работе с ними через интерфейсные переменные:
var
Obj: TDelimitedReader;
Intf, Copy: ITextReader;
begin
Obj := TDelimitedReader.Create('MyData.del', ';');
Intf := Obj; // Obj._AddRef -> Obj.FRefCount = 1
Copy := Intf; // Obj._AddRef -> Obj.FRefCount = 2
...
Intf := nil; // Obj._Release -> Obj.FRefCount = 1
Copy := nil; // Obj._Release -> Obj.FRefCount = 0 -> Obj.Destroy
Obj.Free; // Ошибка! Объект уже уничтожен и переменная Obj указывает в никудаend;
|
Обратите внимание, что объектные переменные не учитываются при подсчете ссылок. Поэтому мы настоятельно рекомендуем избегать смешивания интерфейсных и объектных переменных. Если вы планируете использовать объект через интерфейс, то лучше всего результат работы конструктора сразу присвоить интерфейсной переменной:
var
Intf: ITextReader;
begin
Intf := TDelimitedReader.Create('MyData.del', ';'); // FRefCount = 1
...
Intf := nil; // FRefCount = 0 -> Destroyend;
|
Если интерфейс является входным параметром подпрограммы, то при вызове подпрограммы создается копия интерфейсной переменной с вызовом метода _AddRef:
procedure LoadItems(R: ITextReader);
begin
...
end;
var
Reader: ITextReader;
begin
...
LoadItems(Reader); // Создается копия переменной Reader и вызывается Reader._AddRefend;
|
Копия не создается, если входной параметр описан с ключевым словом const:
procedure LoadItems(const R: ITextReader);
begin
...
end;
var
Reader: ITextRedaer;
begin
...
LoadItems(Reader); // Копия не создается, метод _AddRef не вызывается end;
|
Интерфейсная переменная уничтожается при выходе из области действия переменной, а это значит, что у нее автоматически вызывается метод _Release:
var
Intf: ITextRedaer;
begin
Intf := TDelimitedReader.Create('MyData.del', ';');
...
end; // Intf._Release |
Глубокое понимание работы интерфейсов требует знания их технической реализации. Поэтому вам необходимо разобраться в том, как представляется интерфейс в оперативной памяти компьютера, и что стоит за операторами Intf := Obj и Intf.NextLine.
Интерфейс по сути выступает дополнительной таблицей виртуальных методов, ссылка на которую укладывается среди полей объекта (рисунок 6.5). Эта таблица называется таблицей методов интерфейса. В ней хранятся указатели на методы класса, реализующие методы интерфейса.
Интерфейсная переменная хранит ссылку на скрытое поле объекта, которое содержит указатель на таблицу методов интерфейса. Когда интерфейсной переменной присваивается значение объектой переменной,
Intf := Obj; // где Intf: ITextReader и Obj: TTextReader |
к адресу объекта добавляется смещение до скрытого поля внутри объекта и этот результат заносится в интерфейсную переменную. Чтобы убедиться в сказанном, посмотрите в отладчике значения Pointer(Obj) и Pointer(Intf) сразу после выполнения оператора Intf := Obj. Эти значения будут разными! Причина в том, что объектная ссылка указывает на начало объекта, а интерфейсная ссылка — на скрытое поле внутри объекта.
Рисунок 6.5. Представление интерфейса в памяти
Алгоритм вызова метода интерфейса такой же, как алгоритм вызова метода класса. Когда через интерфейсную переменную выполняется вызов метода,
Intf.NextLine; |
реализуется следующий алгоритм:
Обычными средствами процедурного программирования этот алгоритм реализуется так:
type
TMethodTable = array[0..9999] of Pointer;
TNextLineFunc = function (Self: ITextReader): Boolean;
var
Intf: ITextReader; // интерфейсная переменна
IntfPtr: Pointer; // адрес внутри интерфейсной переменной
TablePtr: ^TMethodTable; // указатель на таблицу методов интерфейса
MethodPtr: Pointer; // указатель на методbegin
...
IntfPtr := Pointer(Intf); // 1) извлечение адреса из интерфейсной переменной
TablePtr := Pointer(IntfPtr^); // 2) извлечение адреса таблицы методов интерфейса
MethodPtr := TablePtr^[3]; // 3) извлечение адреса нужного метода из таблицы
TNextLineFunc(MethodPtr)(Intf); // 4) вызов метода через переходник
...
end.
|
Вся эта сложность скрыта в языке Delphi за понятием интерфейса. Причем несмотря на такое количество операторов в примере, вызов метода через интерфейс в машинном коде выполняется весьма эффективно (всего несколько инструкций процессора), поэтому в подавляющем большинстве случаев потерями на вызов можно пренебречь.
Если вы поместите свой класс в DLL-библиотеку, то при необходимости использовать его в главной программе столкнетесь с проблемой. Подключение модуля с классом к главной программе приведет к включению в нее кода всех методов класса, т.е. задача выделения класса в DLL-библиотеку не будет решена. Если же не подключить модуль с описанием класса, главная программа вообще не будет знать о существовании класса, и воспользоваться классом будет невозможно. Эта проблема решается с помощью интерфейсов. Покажем это на примере модуля ReadersUnit.
Сначала вынесем описание интерфейса ITextReader в отдельный модуль (например, ReaderIntf), чтобы этот модуль в дальнейшем можно было подключить к главной программе:
unit ReadersIntf;
interfacetype
ITextReader = interface(IInterface)
...
end;
implementationend.
|
Затем удалим описание интерфейса из модуля ReadersUnit, а вместо него подключим модуль ReaderIntf:
unit ReadersUnit;
interfaceuses
ReaderIntf;
...
|
Наконец включим скорректированный модуль ReadersUnit в DLL-библиотеку, которую назовем ReadersLib:
library ReadersLib;
uses
SysUtils, Classes, ReadersUnit;
{$R *.res}beginend.
|
Вроде бы все готово, и теперь в главной программе достаточно подключить модуль ReaderIntf и работать с объектами через интерфейс ITextReader (рисунок 6.6).
Рисунок 6.6. Схема получения программы и DLL-библиотеки
Но постойте! А как в программе создавать объекты классов, находящихся в DLL-библиотеке? Ведь в интерфейсе нет методов для создания объектов! Для этого определим в DLL-библиотеке специальную функцию и экспортируем ее:
library ReadersLib;
...
function GetDelimitedReader(const FileName: string;
const Delimiter: Char = ';'): ITextReader;
begin
Result := TDelimitedReader.Create(FileName, Delimiter);
end;
exports
GetDelimitedReader;
beginend.
|
В главной программе импортируйте функцию GetDelimitedReader, чтобы с ее помощью создавать объекты класса TDelimitedReader:
program Example;
uses
ReadersIntf;
function GetDelimitedReader(const FileName: string;
const Delimiter: Char = ';'): ITextReader;
external'ReadersLib.dll'name'GetDelimitedReader';
var
Intf: ITextReader;
begin
Intf := GetDelimitedReader;
...
end.
|
Теперь вы знаете, как разместить объекты в DLL-библиотеке. Смело пользуйтесь динамически загружаемыми библиотеками, не теряя преимуществ ООП.
Вы прочитали и усвоили весь материал всех предыдущих глав? Тогда спешим вас поздравить! Можете смело утверждать, что знаете язык программирования Delphi. Что же дальше? Вас ждет новая высота — среда программирования Delphi. Сейчас вы имеете лишь поверхностное представление о ее возможностях. Настало время подготовить себя к профессиональной работе в среде Delphi.
| Сообщений 19 Оценка 112 Оценить
|