Введение

COM (Component Object Model) — модель объектных компонентов — одна из основных технологий, на которых основывается Windows. Более того, все новые технологии в Windows (Shell, Scripting, поддержка HTML и т.п.) реализуют свои API именно в виде COM-интерфейсов. Таким образом, в настоящее время профессиональное программирование требует понимания модели COM и умения с ней работать. В этой главе мы рассмотрим основные понятия COM и особенности их поддержки в Delphi.

Ключевым моментом, на котором основана модель COM, является понятие интерфейса. Не имея четкого понимания того, что такое интерфейс, успешное программирование COM-объектов невозможно.

Интерфейс

Интерфейс, образно говоря, является «контрактом» между программистом и компилятором. Программист обязуется реализовать все методы, описанные в интерфейсе, и следовать требованиям, предъявляемым к реализации некоторых их них.

Компилятор обязуется создать в программе внутренние структуры, позволяющие обращаться к методам этого интерфейса из любого поддерживающего те же соглашения средства программирования. Таким образом, COM является языково-независимой технологией и может использоваться в качестве «клея», соединяющего программы, написанные на разных языках.

Объявление интерфейса включает в себя описание методов и их параметров, но не включает их реализации. Кроме того, в объявлении может указываться идентификатор интерфейса — уникальное 16-байтовое число, сгенерированное по специальным правилам, гарантирующим его статистическую уникальность (GUID — Global Unique Identifier).

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

Таким образом, необходимо понимать следующее:

  • Интерфейс не является классом. Класс может выступать реализацией интерфейса, но класс содержит код методов на конкретном языке программирования, а интерфейс — нет.
  • Интерфейс строго типизирован. Как клиент, так и реализация интерфейса должны использовать точно те же методы и параметры, что указаны в описании интерфейса.
  • Интерфейс является «неизменным контрактом». Нельзя определять новую версию того же интерфейса с измененным набором методов (или их параметров), но с тем же идентификатором.

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

Реализация интерфейса — это код, который реализует эти методы. При этом, за несколькими исключениями, не накладывается никаких ограничений на то, каким образом будет выглядеть реализация. Физически реализация представляет собой массив указателей на методы, адрес которого и используется в клиенте для доступа к COM-объекту. Любая реализация интерфейса имеет метод QueryInterface, позволяющий запросить ссылку на конкретный интерфейс из числа реализуемых.

Автоматическое управление памятью и подсчет ссылок

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

Объявление интерфейсов

Для поддержки интерфейсов Delphi расширяет синтаксис языка Pascal дополнительными ключевыми словами. Объявление интерфейса в Delphi реализуется ключевым словом interface:

type IMyInterface = interface
['{412AFF00-5C21-11D4-84DD-C8393F763A13}']
procedure DoSomething(var I: Integer); stdcall;
function DoSomethingAnother(S: String): Boolean;
end;

IMyInterface2 = interface(IMyInterface)
['{412AFF01-5C21-11D4-84DD-C8393F763A13}']
procedure DoAdditional(var I: Integer); stdcall;
end;

Для генерации нового значения GUID в IDE Delphi служит сочетание клавиш Ctrl+Shift+G.

IUnknown

Базовым интерфейсом в модели COM является IUnknown. Любой интерфейс наследуется от IUnknown и обязан реализовать объявленные в нем методы. IUnknown объявлен в модуле System.pas следующим образом:

type
IUnknown = interface
['{00000000-0000-0000-C000-000000000046}']
function QueryInterface(const IID: TGUID; out Obj): HResult; stdcall;
function _AddRef: Integer; stdcall;
function _Release: Integer; stdcall;
end;

Рассмотрим назначение методов IUnknown более подробно. Последние два метода предназначены для реализации механизма подсчета ссылок.

function _AddRef: Integer; stdcall;

- Эта функция должна увеличить счетчик ссылок на интерфейс на единицу и вернуть новое значение счетчика.

function _Release: Integer; stdcall;

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

А первый метод позволяет получить ссылку на реализуемый классом интерфейс:

function QueryInterface(const IID: TGUID; out Obj): HResult; stdcall;

- Эта функция получает в качестве входного параметра идентификатор интерфейса. Если объект реализует запрошенный интерфейс, то функция:

  1. возвращает ссылку на него в параметре Obj;
  2. вызывает метод _AddRef полученного интерфейса;
  3. возвращает 0.

В противном случае — функция возвращает код ошибки E_NOINTERFACE.

В принципе, конкретная реализация может наполнить эти методы какой-либо другой, отличающейся от стандартной функциональностью, однако в этом случае интерфейс будет несовместим с моделью COM, поэтому делать этого не рекомендуется.

В модуле System.pas объявлен класс TInterfacedObject, реализующий IUnknown и его методы. Рекомендуется использовать этот класс для создания реализаций своих интерфейсов.

Кроме того, поддержка интерфейсов реализована в базовом классе TObject. Он имеет метод

function TObject.GetInterface(const IID: TGUID; out Obj): Boolean;

Если класс реализует запрошенный интерфейс, то функция:

  1. возвращает ссылку на него в параметре Obj;
  2. вызывает метод _AddRef полученного интерфейса;
  3. возвращает TRUE.

В противном случае — функция возвращает FALSE.

Таким образом, имеется возможность запросить у любого класса Delphi реализуемый им интерфейс. Подробнее использование этой функции рассмотрено ниже.

Реализация интерфейсов

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

TMyClass = class(TComponent, IMyInterface, IDropTarget)
// Реализация методов
end;

Класс TMyClass реализует интерфейсы IMyInterface и IDropTarget. Необходимо понимать, что реализация классом нескольких интерфейсов не означает множественного наследования и вообще наследования класса от интерфейса. Указание интерфейсов в описании класса означает только то, что в данном классе реализованы все эти интерфейсы.

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

Рассмотрим более подробный пример.

type ITest = interface
['{61F26D40-5CE9-11D4-84DD-F1B8E3A70313}']
procedure Beep;
end;

TTest = class(TInterfacedObject, ITest)
procedure Beep;
destructor Destroy; override;
end;

procedure TTest.Beep;
begin
Windows.Beep(0,0);
end;

destructor TTest.Destroy;
begin
inherited;
MessageBox(0, 'TTest.Destroy', NIL, 0);
end;

Здесь класс TTest реализует интерфейс ITest. Рассмотрим использование интерфейса из программы.

procedure TForm1.Button1Click(Sender: TObject);
var Test: ITest;
begin
Test := TTest.Create;
Test.Beep;
end;

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

Во-первых, оператор присваивания при приведении типа данных к интерфейсу неявно вызывает метод _AddRef. При этом количество ссылок на интерфейс увеличивается на единицу.

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

Внимание! Если у класса запрошен хотя бы один интерфейс - не вызывайте его метод Free (или Destroy). Класс будет освобожден тогда, когда отпадет необходимость в последней ссылке на его интерфейсы. Если вы к этому моменту уничтожили экземпляр класса вручную - произойдет ошибка доступа к памяти.

Так, следующий код приведет к ошибке в момент выхода из функции:

var
Test: ITest;
T: TTest;
begin
	T := TTest.Create;
	Test := T;
	Test.Beep;
	T.Free;
end; // в этот момент произойдет ошибка

Если вы хотите уничтожить реализацию интерфейса немедленно, не дожидаясь выхода переменной за область видимости, – просто присвойте ей значение NIL:

var
Test: ITest;
T: TTest;
begin
	T := TTest.Create;
	Test := T;
	Test.Beep;
	Test := NIL; //Неявно вызывается IUnknown._Release;
end;

Обратите особое внимание, что вызовы методов интерфейса IUnknown осуществляются Delphi неявно и автоматически. Поэтому не вызывайте методы интерфейса IUnknown самостоятельно. Это может нарушить нормальную работу автоматического подсчета ссылок и привести к неосвобождению памяти либо к нарушениям защиты памяти при работе с интерфейсами. Во избежание этого необходимо просто помнить следующее.

  1. При приведении типа объекта к интерфейсу вызывается метод _AddRef.
  2. При выходе переменной, ссылающейся на интерфейс, за область видимости либо при присвоении ей другого значения вызывается метод _Release.
  3. Единожды запросив у объекта интерфейс, в дальнейшем вы не должны освобождать объект вручную. Вообще начиная с этого момента лучше работать с объектом только через интерфейсные ссылки.

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

Например, следующий код будет успешно откомпилирован, но при выполнении вызовет ошибку «Interface not supported»:

var
Test: ITest;
begin
	Test := TInterfacedObject.Create as ITest;
	Test.Beep;
end;

В то же время код

var
Test: ITest;
begin
	Test := TTest.Create as ITest;
	Test.Beep;
end;

будет успешно компилироваться и выполняться.

Реализация интерфейсов (расширенное рассмотрение)

Рассмотрим вопросы реализации интерфейсов подробнее.

Объявим два интерфейса:

type ITest = interface
['{61F26D40-5CE9-11D4-84DD-F1B8E3A70313}']
procedure Beep;
end;

type ITest2 = interface
'{61F26D42-5CE9-11D4-84DD-F1B8E3A70313}']
procedure Beep;
end;

Теперь создадим класс, который будет реализовывать оба этих интерфейса:

TTest2 = class(TInterfacedObject, ITest, ITest2)
procedure Beep1;
procedure Beep2;
procedure ITest.Beep = Beep1;
procedure ITest2.Beep = Beep2;
end;

Как видно, класс не может содержать сразу два метода Beep. Поэтому Delphi предоставляет способ для разрешения конфликтов имен, позволяя явно указать, какой метод класса будет служить реализацией соответствующего метода интерфейса.

Если реализация методов TTest2.Beep1 и TTest2.Beep2 идентична, то можно не создавать два разных метода, а объявить класс следующим образом:

TTest2 = class(TInterfacedObject, ITest, ITest2)
procedure MyBeep;
procedure ITest.Beep = MyBeep;
procedure ITest2.Beep = MyBeep;
end;

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

type TBeeper = class
procedure Beep;
end;

TMessager = class
procedure ShowMessage(const S: String);
end;

TTest3 = class(TInterfacedObject, ITest, IAnotherTest)
private
FBeeper: TBeeper;
FMessager: TMessager;
property Beeper: TBeeper read FBeeper implements ITest;
property Messager: TMessager read FMessager implements IAnotherTest;
public
constructor Create;
destructor Destroy; override;
end;

Для делегирования реализации интерфейса другому классу служит ключевое слово implements.

{ TBeeper }
procedure TBeeper.Beep;
begin
	Windows.Beep(0,0);
end;

{ TMessager }
procedure TMessager.ShowMessage(const S: String);
begin
	MessageBox(0, PChar(S), NIL, 0);
end;

{ TTest3 }
constructor TTest3.Create;
begin
	inherited;
    // Создаем экземпляры дочерних классов
    FBeeper := TBeeper.Create;
    FMessager := TMessager.Create;
end;

destructor TTest3.Destroy;
begin
    // Освобождаем экземпляры дочерних классов
    FBeeper.Free;
    FMessager.Free;
    inherited;
end;

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

Обращаться к полученному классу можно точно так же, как и к любому классу, реализующему интерфейсы:

var
Test: ITest;
Test2: IAnotherTest;
begin
	Test2 := TTest3.Create;
	Test2.ShowMessage('Hi');
	Test := Test2 as ITest;
	Test.Beep;
end;

Delphi: COM, Интерфейсы, dll, COM-сервер. Часть 2.