WWW.DISSERS.RU

БЕСПЛАТНАЯ ЭЛЕКТРОННАЯ БИБЛИОТЕКА

   Добро пожаловать!

Pages:     | 1 |   ...   | 2 | 3 || 5 | 6 |

«Основы 2-е издание, исправленное и переработанное Дейл Роджерсон Оглавление ОТ АВТОРА ...»

-- [ Страница 4 ] --

затем разработаем несколько классов, облегчающих разработку компонентов.

Упрощения на клиентской стороне Большинство из Вас не надо убеждать, что использовать компоненты СОМ вовсе не так просто, как обычные классы С++. Во-первых, необходимо подсчитывать ссылки. Если Вы забыли вызвать AddRef для указателя на интерфейс, можете сразу прощаться с выходными. Если ссылки подсчитываются неправильно, программа может попытаться работать с интерфейсом уже удаленного компонента, что кончится сбоем. Найти пропущенный вызов AddRef или Release нелегко. Хуже того, при каждом новом запуске программы компонент может освобождаться в разных точках. Хотя мне доставляет настоящее удовольствие отлавливать трудновоспроизводимые ошибки (в обществе нескольких друзей и пиццы), не многие, кажется, разделяют эту радость.

Поддержка СОМ в компиляторе Компилятор Microsoft Visual C++ версии 5.0 вводит расширения языка С++, упрощающие разработку и использование компонентов СОМ. Для получения более подробной информации обратитесь к документации Visual С++ версии 5.0.

Даже если Вы вписали вызовы Release там, где нужно, Ваша программа может их не выполнить. Обработчики исключений С++ ничего не знают о компонентах СОМ. Поэтому Release не вызывается автоматически после возникновения исключений.

Простая и корректная обработка AddRef и Release — лишь полдела. Нужно еще упростить вызов QueryInterface, Вы, я уверен, давно заметили, что один такой вызов занимает несколько строк. Несколько вызовов внутри одной функции могут легко затенить содержательный код. Я обхожу эту проблему, сохраняя указатели и интерфейсы, а не запрашивая их при всякой нужде. Это повышает производительность и надежность кода — за счет памяти. Но с QueryInterface связана и более тяжелая проблема — вызов требует явного приведения типов. Если Вы перепутаете параметры, передаваемые QueryInterface, компилятор Вам не поможет. Например, следующий код прекрасно компилируется, хотя он и помещает указатель на интерфейс IY в переменную-указатель на IZ:

IZ* pIZ;

PIX->QueryInterface(IID_IY, (void**)&pIZ);

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

Эти проблемы можно устранить при помощи инкапсуляции. Можно либо инкапсулировать указатель на интерфейс при помощи класса smart-указателя, либо инкапсулировать сам интерфейс внутри класса-оболочки (wrapper). Давайте рассмотрим эти методы, начиная со smart-указателей.

Smart-указатели на интерфейсы Первый способ упрощения кода клиента — использование для доступа к компонентам smart-указателей вместо обычных указателей на интерфейс. Smart-указатель используется так же, как обычный указатель С++, но он скрывает подсчет ссылок. Когда поток управления выходит из области действия переменной-smart-указателя, интерфейс автоматически освобождается. Это делает использование интерфейса СОМ аналогичным использованию объекта С++.

Что такое smart-указатель?

Smart-указатель (smart pointer) — это класс, переопределяющий operator-> (оператор выбора метода). Класс smart-указателя содержит указатель на другой объект. Когда для smart-указателя вызывается operator->, этот вызов делегируется или передается smart-указателем объекту, на который ссылается содержащийся в нем указатель. Smart-указатель на интерфейс — это smart-указатель, содержащий указатель на интерфейс.

Рассмотрим простой пример. CFooPointer имеет минимум возможностей, необходимых классу smart-указателя.

Он содержит указатель и переопределяет operator->.

class CFoo { public:

virtual void Bar();

};

class CFooPointer { public:

CFooPointer (Cfoo*p) { m_p = p;

} CFoo* operator->() { return m_p;

} private:

CFoo* m_p;

};

...

void Funky(CFoo* pFoo) { // Создать и инициализировать smart-указатель CFooPointer spFoo(pFoo);

// Следующий оператор эквивалентен pFoo->Bar();

spFoo->Bar();

} В приведенном примере функция Funky создает CFooPointer с именем spFoo и инициализирует его с помощью pFoo. Затем она выполняет разыменование spFoo для вызова функции Bar. Указатель spFoo делегирует этот вызов m_p, которая содержит pFoo. С помощью spFoo можно вызвать любой метод CFoo. Самое замечательное здесь то, что Вам не нужно явно перечислять в CFooPointer все методы CFoo. Для CFoo функция operator-> означает «разыменуй меня»*. В то же время для CFooPointer она означает «разыменуй не меня, а m_p» (см. рис.

9-1)**.

Для умного (smart) указателя CFooPointer глуповат. Он ничего не делает. Хороший компилятор, вероятно, вообще его устранит во время оптимизации. Кроме того, CFooPointer не слишком похож на обычный указатель.

Попробуйте присвоить pFoo переменной spFoo. Присваивание не сработает, так как operator= (оператор присваивания) не переопределен соответствующим образом. Для того, чтобы CFooPointer выглядел так же, как и указатель CFoo, для CFooPointer необходимо переопределить несколько операторов. Сюда входят operator* (оператор разыменования) и operator& (оператор получения адреса), которые должны работать с указателем m_p, а не с самим объектом CFooPointer.

Реализация класса указателя на интерфейс Хотя классов smart-указателей для работы с интерфейсами СОМ и не так много, как классов строк, но число тех и других не сильно различается. ActiveX Template Library (ATL) содержит классы указателей на интерфейсы СОМ CComPtr и CComQIPtr. В библиотеке MFC имеется класс CIP для внутреннего пользования. (Он находится в файле AFXCOM_.H.) CIP — это самый полный вариант класса smart-указателя на интерфейс. Он делает практически все. Здесь я представлю свой собственный, главным образом потому, что мой код легче читается.

Мой класс похож на классы из ATL и MFC, но не столь полон.

* Точнее, для указателя CFoo*. — Прим. перев.

** Функция operator-> означает не «разыменуй меня», а «используй меня для обращения к моим методам или переменным-членам» — Прим..

перев.

Клиент Код Код клиента smart-указателя Указатель Компонент Клиент вызывает на интерфейс члены интерфейса напрямую m_pIX IX с помощью operator-> IY Функции-члены Доступ к функциям-членам IZ класса smart-указателя осуществляется с использованием нотации "точка" Рис. 9-1 Smart-указатели на интерфейсы делегируют вызовы указателю на интерфейс, хранящемуся внутри класса.

Мой класс указателя на интерфейс называется IPtr и реализован в файле PTR.H, который представлен в листинге 9-1. Пусть длина исходного текста Вас не пугает. Кода там очень мало. Я просто вставил побольше пустых строк, чтобы легче было читать.

Шаблон IPtr из PTR.H // // IPtr – Smart-указатель на интерфейс // Использование: IPtr spIX;

// Не используйте с IUnknown;

IPtr // не будет компилироваться. Вместо этого используйте IUnknownPtr.

// template class IPtr { public:

// Конструкторы IPtr() { m_pI = NULL;

} IPtr(T* lp) { m_pI = lp;

if (m_pI != NULL) { m_pI->AddRef();

} } IPtr(IUnknown* pI) { m_pI = NULL;

if (pI != NULL) { pI->QueryInterface(*piid, (void **)&m_pI);

} } // Деструктор ~IPtr() { Release();

} // Сброс в NULL void Release() { if (m_pI != NULL) { T* pOld = m_pI;

m_pI = NULL;

pOld->Release();

} } // Преобразование operator T*() { return m_pI;

} // Операции с указателем T& operator*() { assert(m_pI != NULL);

return *m_pI;

} T** operator&() { assert(m_pI == NULL);

return &m_pI;

} T* operator->() { assert(m_pI != NULL);

return m_pI;

} // Присваивание того же интерфейса T* operator=(T* pI) { if (m_pI != pI) { IUnknown* pOld = m_pI;

// Сохранить старое значение m_pI = pI;

// Присвоить новое значение if (m_pI != NULL) { m_pI->AddRef();

} if (pOld != NULL) { pOld->Release();

// Освободить старый интерфейс } } return m_pI;

} // Присваивание другого интерфейса T* operator=(IUnknown* pI) { IUnknown* pOld = m_pI;

// Сохранить текущее значение m_pI == NULL ;

// Запросить соответствующий интерфейс if (pI != NULL) { HRESULT hr = pI->QueryInterface(*piid, (void**)&m_pI);

assert(SUCCEEDED(hr) && (m_pI != NULL));

} if (pOld != NULL) { pOld->Release();

// Освободить старый указатель } return m_pI;

} // Логические функции BOOL operator!() { return (m_pI == NULL) ? TRUE : FALSE;

} // Требует компилятора, поддерживающего BOOL operator BOOL() const { return (m_pI != NULL) ? TRUE : FALSE;

} // GUID const IID& iid() { return *piid;

} private:

// Хранимый указатель T* m_pI;

};

Листинг 9-1. Класс smart-указателей на интерфейсы IPtr.

Использование класса указателя на интерфейс Использовать экземпляр IPtr легко, особенно для шаблона класса. Во-первых, Вы создаете указатель, передавая тип интерфейса и указатель на его IID. (Неплохо было бы использовать как параметр шаблона ссылку, но большинство компиляторов этого не допускают.) Теперь можно вызвать CoCreateInstance для создания компонента и получения указателя на него. В приведенном далее примере Вы можете видеть, насколько эффективно IPtr эмулирует настоящий указатель. Мы можем использовать с IPtr operator& как будто это настоящий указатель:

void main() { IPtr spIX;

HRESULT hr = ::CoCreateInstance(CLSID_Component1, NULL, CLSCTX_ALL, spIX.iid(), (void**)&spIX);

if (SUCCEEDED(hr)) { spIX->Fx();

} } Предыдущий вызов CoCreateInstance небезопасен в смысле приведения типов, но его можно подправить, определив в шаблоне IPtr другую функцию:

HRESULT CreateInstance(const CLSID& clsid, IUnkown* pI, DWORD clsctx) { Release();

return CoCreateInstance(clsid, pI, clsctx, *piid, (void**)&m_pI);

} Ее можно было бы использовать так:

IPtr spIX;

HRESULT hr = spPX.CreateInstance(CLSID_Component1, NULL, CLSCTX_INPROC_SERVER);

Между прочим, для своих переменных-smart-указателей я использую префикс sp, что позволяет отделить smart указатели от тех, что не наделены интеллектом.

Подсчет ссылок Самое замечательное в примере со smart-указателями то, что нам не нужно помнить о вызовах Release. Когда поток управления выходит из области действия smart-указателя, деструктор последнего автоматически вызывает Release. Кроме того, интерфейс будет автоматически освобожден и в случае возникновения исключения, так как smart-указатель — это объект С++.

Если Вы хотите освободить указатель на интерфейс, хранящийся в smart-указателе, не следует вызывать Release.

Smart-указатель ничего не знает о функциях, которые вызываются с его помощью, а слепо делегирует им вызовы.

Поэтому, если освободить интерфейс, в smart-указателе по-прежнему будет храниться не NULL. Попытка использовать такой smart-указатель приведет к нарушению защиты памяти.

Для разных smart-указателей есть свои способы сообщить им, что Вы хотите освободить интерфейс.

Большинство, включая IPtr, реализуют функцию Release, которая вызывается с использованием нотации «точка», а не через operator->:

spIX.Release();

Другой способ освобождения интерфейса в IPtr — присвоить ему значение NULL:

spIX = NULL;

Чтобы понять, почему это работает, рассмотрим, как IPtr переопределяет оператор присваивания.

Присваивание Класс IPtr переопределяет operator=, чтобы указатель на интерфейс можно было присваивать smart-указателю:

T* operator=(T* pI) { if (m_pI != pI) { IUnknown* pOld = m_pI;

m_pI = pI;

if (m_pI != NULL) { m_pI->AddRef();

} if (pOld != NULL) { pOld->Release();

} } return m_pI;

} Обратите внимание на два интересных момента реализации operator=. Во-первых, она вызывает AddRef и Release, так что нам не нужно делать это самостоятельно. Во-вторых, smart-указатель на интерфейс освобождает свой текущий указатель после присваивания нового. Это предотвращает удаление компонента из памяти до присваивания.

Представленный ниже фрагмент кода присваивает значение указателя pIX1 члену m_p переменной spIX. По ходу дела операция присваивания вызывает для указателя AddRef. После использования spIX ей присваивается pIX2.

Переопределенная функция operator= копирует во временную переменную текущий указатель, который указывает на интерфейс pIX1, сохраняет pIX2 и вызывает AddRef для pIX2.

void Fuzzy(IX* pIX1, IX* pIX2) { IPtr spIX;

spIX=pIX1;

spIX->Fx();

spIX = pIX2;

spIX->Fx();

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

typedef IPtr SPIX;

SPIX g_spIX;

void Wuzzy(SPIZ spIX) { g_spIX = spIX;

} Эта операция присваивания работает, только если оба указателя имеют один тип. Обратите внимание на использование typedef для повышения читабельности кода.

Присваивание IUnknown Как Вы помните, одной из наших целей было упростить вызов QueryInterface. Это можно сделать при помощи еще одной совмещенной операции присваивания.

T* operator=(IUnknown* pIUnknown);

Если Вы присваиваете указатель на интерфейс, тип которого отличен от типа smart-указателя, операция присваивания автоматически вызовет QueryInterface. Например, в следующем далее фрагменте кода указатель на IY присваивается smart-указателю на IX. Не забывайте проверить значение указателя, чтобы убедиться в том, что присваивание было успешным. Некоторые классы smart-указателей генерируют исключение, если вызов QueryInterface заканчивается ошибкой.

void WasABear(IY* pIY) { IPtr spIX;

spIX = pIY;

if (spIX) { spIX->Fx();

} } Лично мне не нравится операция присваивания, вызывающая QueryInterface. Одно из правил переопределения операций рекомендует, чтобы переопределенная версия вела себя аналогично обычной, встроенной. Очевидно, что в случае операции присваивания с вызовом QueryInterface это не так. Оператор присваивания С++ всегда выполняется успешно. Но вызов QueryInterface может закончиться неудачей, поэтому и вызывающая его операция присваивания тоже может не сработать.

К сожалению, вся индустрия информатики в этом вопросе против меня. Microsoft Visual Basic содержит операцию присваивания, которая вызывает QueryInterface. Smart-указатели на интерфейсы в ATL и MFC также переопределяют операцию присваивания, чтобы вызывать QueryInterface.

interface_cast Я действительно не люблю скрывать значительные объемы своего кода за невинно выглядящими присваиваниями. То, что Visual Basic вызывает во время присваивания QueryInterface, не означает, что и в С++ правильно и целесообразно так делать. Может быть, в смысле синтаксиса С++ — это дурной сон, но тогда Visual Basic — ночной кошмар.

Я предпочитаю инкапсулировать QueryInterface при помощи функции, которую назвал interface_cast.

interface_cast — это функция-шаблон, которая используется аналогично dynamic_cast. Вот она:

template I* interface_cast(IUnknown* pIUnknown) { I* pI = NULL;

HRESULT hr = pIUnknown->QueryInterface(*pGUID, (void**)&pI);

assert(SUCCEEDED(hr));

return pI;

} Используется interface_cast так:

IY* pIX = interface_cast(this);

Приятная особенность interface_cast состоит в том, что для ее использования даже не нужны smart-указатели.

Плохая же сторона в том, что Вам потребуется компилятор, который поддерживает явную генерацию экземпляров (explicit instantiation) функций-шаблонов. По счастью, Visual C++ версии 5.0 — именно такой компилятор.

IUnknownPtr В дополнение к IPtr в PTR.H находится еще один класс указателя — IUnknownPtr — версия IPtr, предназначенная для использования с IUnknown. Класс IUnknownPtr не является шаблоном и не реализует операцию присваивания, вызывающую QueryInterface. Я создал IUnknownPtr потому, что IPtr нельзя использовать с IUnknown в качестве параметра шаблона. Попытка сгенерировать вариант IPtr для IUnknown приведет к порождению двух операций присваивания с одинаковыми прототипами. Не используйте IPtr для объявления smart-указателя на IUnknown:

IPtr spIUnknown;

// Ошибка Вместо этого применяйте IUnknownPtr:

IUnknownPtr spIUnknown;

Реализация клиента с помощью smart-указателей В примеры этой главы, находящиеся на прилагаемом к книге диске, входит код двух клиентов. Клиент реализован так же, как в предыдущих главах. Клиент 2 — через smart-указатели. В листинге 9-2 показан код Клиента 2. Очевидно, когда все вызовы QueryInterface скрыты, код читается гораздо легче. Как обычно, с помощью typedef использование классов шаблонов можно сделать еще удобнее. Я поместил весь код, который работает с компонентом, в функцию Think.

CLIENT2.CPP // // Client2.cpp – Реализация клиента с помощью smart-указателей // #include #include "Iface.h" #include "Util.h" // Трассировка с метками #include "Ptr.h" // Классы smart-указателей static inline void trace(const char* msg) { Util::Trace("Клиент 2", msg, S_OK);

} static inline void trace(const char* msg, HRESULT hr) { Util::Trace("Клиент 2", msg, hr);

} void Think() { trace("Создать Компонент 1");

IPtr spIX;

HRESULT hr = CoCreateInstance(CLSID_Component1, NULL, CLSCTX_INPROC_SERVER, spIX.iid(), (void**)&spIX);

if (SUCCEEDED(hr)) { trace("Компонент успешно создан");

spIX->Fx();

trace("Получить интерфейс IY");

IPtr spIY;

spIY = spIX;

// Используется присваивание if (spIY) { spIY->Fy();

trace("Получить интерфейс IX через IY");

IPtr spIX2(spIY);

// Используется конструктор if (!spIX2) { trace("Не могу получить интерфейс IX через IY");

} else { spIX2->Fx();

} } trace("Получить интерфейс IZ");

IPtr spIZ;

spIZ = spIX;

if (spIZ) { spIZ->Fz();

trace("Получить интерфейс IX через IZ");

IPtr spIX2(spIZ);

if (!spIX2) { trace("Не могу получить интерфейс IX через IZ");

} else { spIX2->Fx();

} } } else { trace("Не могу создать компонент", hr);

} } int main() { // Инициализировать библиотеку COM CoInitialize(NULL);

// Упражнения со smart-указателями Think();

// Освободить библиотеку COM CoUninitialize();

return 0;

} Листинг 9-2 Клиент 2 использует класс smart-указателей на интерфейсы IPtr Обратите внимание, как в примере обрабатываются возможные ошибки инкапсулированных QueryInterface. Для проверки успешного завершения мы используем функцию преобразования в тип BOOL, которая возвращает TRUE, если IPtr::m_p есть не NULL. Для проверки на ошибку применяется operator!.

Проблемы smart-указателей Большинство этих проблем незначительно. Вам необходимо избегать вызова Release для smart-указателей на интерфейсы. Доступ к методам класса smart-указателя осуществляется с помощью «точки», а не «стрелки», которая используется для доступа к методам интерфейса. Все эти проблемы компенсируются необычайной гибкостью классов smart-указателей. Вы можете написать один такой класс, который будет работать для всех интерфейсов (кроме IUnknown).

Однако это свойство smart-указателей является их главным недостатком. Smart-указатели настолько универсальны, что инкапсулируют не используемый Вами интерфейс, но использование указателей на интерфейс. Для большинства простых интерфейсов это идеально. Но в некоторых случаях лучше инкапсулировать сам интерфейс.

Классы-оболочки C++ Smart-указатели прекрасно подходят, когда Вы хотите инкапсулировать группу интерфейсов. Для инкапсуляции конкретного интерфейса используйте класс-оболочку С++. Класс-оболочка (wrapper class) — это просто клиент одного или нескольких интерфейсов СОМ, предоставляющий абстракцию использования этих интерфейсов.

Ваша программа вызывает методы класса-оболочки, которые вызывают методы интерфейса СОМ. Классы оболочки упрощают вызовы интерфейсов СОМ, подобно тому, как классы-оболочки MFC упрощают работу с Win32 (рис. 9-2).

Важнейшая отличительная черта классов-оболочек — то, что они могут использовать такие средства С++, как совмещение имен функций, совмещение операторов и параметры по умолчанию;

благодаря этому программиста на С++ может работать с классами-оболочками привычным способом. В Visual C++ имеется инструмент, автоматически генерирующий классы-оболочки для управляющих элементов ActiveX и многих других компонентов СОМ.

Клиент Компонент Код клиента Указатели на Методы интерфейсы m_pIX IX Код клиента вызывает методы, m_pIY IY которые работают с интерфейсами непосредственно m_pIZ IZ Рис. 9-2 Классы-оболочки могут инкапсулировать интерфейсы компонента и значительно облегчить работу с ним Классы-оболочки — аналог включения… В отличие от smart-указателей, классы-оболочки должны повторно реализовывать все функции интерфейсов, оболочками которых они являются — даже в том случае, если они не добавляют к самим интерфейсам никакой новой функциональности. Другое существенное различие между классами-оболочками и smart-указателями — то, что первые могут добавить новый код перед вызовом функции интерфейса и после него. Если Вы сравните это с приемами повторного применения компонентов из предыдущей главы, то станет очевидно, что классы-оболочки являются аналогами включения, тогда как smart-указатели — агрегирования.

Оболочки нескольких интерфейсов Классы-оболочки используют также для объединения в один логический блок нескольких интерфейсов. Как Вы помните, у компонентом СОМ обычно много маленьких интерфейсов. Наличие множества интерфейсов дает простор для полиморфного использования компонентов, что подразумевает большую вероятность повторного применения архитектуры. Хотя маленькие интерфейсы прекрасно подходят для повторного использования, в первый раз их трудно использовать. В случае маленьких интерфейсов Вам может понадобиться один интерфейс для сгибания объекта, второй для его распрямления и совершенно иной, чтобы его смять. Это может повлечь множество запросов интерфейсов и соответствующие накладные расходы. Ситуация походит на общение с бюрократической структурой. У каждого бюрократа есть своя строго определенная задача, и с любым вопросом Вам придется обойти множество чиновников. Объединение всех интерфейсов в один класс С++ упрощает использование объектов с данным набором интерфейсов. Поддержка OLE в MFC, по сути дела, осуществляется большим классом-оболочкой.

Используете ли Вы smart-указатели, классы-оболочки или smart-указатели внутри классов-оболочек — эти приемы программирования могут облегчить отладку и чтение кода Вашего клиента.

Упрощения на серверной стороне Теперь пора познакомиться с тем, как упростить реализацию компонентов СОМ. В предыдущем разделе упрощалось использование компонентов. В этом разделе мы собираемся упростить их реализацию. Для этого мы предпримем атаку с двух направлений. Первым будет CUnknown — базовый класс, реализующий IUnknown. Если Ваш класс наследует CUnknown, Вам не нужно беспокоиться о реализации AddRef и Release, а реализация QueryInterface упрощается.

Второе направление атаки — это реализация IClassFactory, которая будет работать с любым компонентом СОМ, производным от CUnknown. Для того, чтобы CFactory могла создать компонент, достаточно просто поместить CLSID и другую информацию в некую структуру данных. CFactory и CFactory — очень простые классы, и Вы легко поймете их исходные тексты. Поэтому основное внимание я собираюсь уделить использованию CUnknown и CFactory для реализации компонента СОМ, а не реализации самих классов. Тем не менее, мы начнем с краткого обзора CUnknown и CFactory. Эти классы будут использоваться в примерах оставшихся глав книги, что и было основной причиной их создания — я хотел сократить себе объем работы.

Базовый класс CUnknown В гл. 8 мы видели, что агрегируемому компоненту нужны два интерфейса IUnknown: делегирующий и неделегирующий. Если компонент агрегируется, делегирующий IUnknown делегирует вызовы IUnknown внешнего компонента. В противном случае он делегирует их неделегирующему IUnknown. Поскольку мы хотим поддерживать компоненты, которые могут быть агрегированы, наш CUnknown должен реализовывать InondelegatingUnknown, а не IUnknown. Заголовочный файл CUnknown показан в листинге 9-3.

CUNKNOWN.H #ifndef CUnknown_h #define CUnknown_h #include /////////////////////////////////////////////////////////// // // Неделегирующий интерфейс IUnknown // - Неделегирующая версия IUnknown // interface INondelegatingUnknown { virtual HRESULT stdcall NondelegatingQueryInterface(const IID& iid, void** ppv) = 0;

virtual ULONG stdcall NondelegatingAddRef() = 0;

virtual ULONG stdcall NondelegatingRelease() = 0;

};

/////////////////////////////////////////////////////////// // // Объявление CUnknown // - Базовый класс для реализации IUnknown // class CUnknown : public INondelegatingUnknown { public:

// Реализация неделегирующего IUnknown virtual HRESULT stdcall NondelegatingQueryInterface(const IID&, void**);

virtual ULONG stdcall NondelegatingAddRef();

virtual ULONG stdcall NondelegatingRelease();

// Конструктор CUnknown(IUnknown* pUnknownOuter);

// Деструктор virtual ~CUnknown();

// Инициализация (особенно важна для агрегатов) virtual HRESULT Init() { return S_OK;

} // Уведомление производным классам об освобождении объекта virtual void FinalRelease();

// Текущий счетчик активных компонентов static long ActiveComponents() { return s_cActiveComponents;

} // Вспомогательная функция HRESULT FinishQI(IUnknown* pI, void** ppv);

protected:

// Поддержка делегирования IUnknown* GetOuterUnknown() const { return m_pUnknownOuter ;

} private:

// Счетчик ссылок данного объекта long m_cRef;

// Указатель на внешний IUnknown IUnknown* m_pUnknownOuter;

// Счетчик общего числа активных компонентов static long s_cActiveComponents;

};

/////////////////////////////////////////////////////////// // // Делегирующий IUnknown // - Делегирует неделегирующему IUnknown или внешнему // IUnknown, если компонент агрегируется // #define DECLARE_IUNKNOWN \ virtual HRESULT stdcall \ QueryInterface(const IID& iid, void** ppv) \ { \ return GetOuterUnknown()->QueryInterface(iid,ppv);

\ };

\ virtual ULONG stdcall AddRef() \ { \ return GetOuterUnknown()->AddRef();

\ };

\ virtual ULONG stdcall Release() \ { \ return GetOuterUnknown()->Release();

\ };

/////////////////////////////////////////////////////////// #endif Листинг 9-3 Базовый класс CUnknown реализует неделегирующий IUnknown. Макрос DECLARE_IUNKNOWN реализует делегирующий IUnknown Реализация интерфейса INondelegatingUnknown в классе CUnknown аналогична той, что была дана для агрегируемого компонента в гл. 8. Конечно, CUnknown не может заранее знать, какие интерфейсы будут реализованы производными компонентами. Как мы увидим ниже, чтобы добавить код для предоставляемых ими интерфейсов, компоненты должны переопределить функцию NondelegatingQueryInterface.

Реализация CUnknown находится в файле CUNKNOWN.CPP на прилагающемся к книге диске. Мы не будем изучать этот код целиком. Однако позвольте кратко рассмотреть еще несколько важных моментов.

Макрос DECLARE_IUNKNOWN Я просто не хочу реализовывать делегирующий IUnknown всякий раз, когда нужно реализовать компонент. В конце концов, именно поэтому и появился CUnknown. Обратившись к листингу 9-3, Вы увидите, в конце макрос DECLARE_IUNKNOWN, реализующий делегирующий IUnknown. Да, я помню, что ненавижу макросы, но чувствую, что здесь это именно то, что нужно. ActiveX Template Library избегает использования обычных макросов;

взамен применяются проверяемые компилятором макросы, более известные как шаблоны.

Еще одна причина использования INondelegatingUnknown Поддержка агрегирования — достаточная причина сама по себе;

но есть и еще одна причина, по которой CUnknown реализует INondelegatingUnknown, а не IUnknown: производный класс обязан реализовать любой абстрактный базовый класс, который наследует. Предположим, что мы используем в качестве абстрактного базового класса IUnknown. Класс CA наследует IUnknown и должен реализовать его чисто виртуальные функции. Но мы хотим использовать существующую реализацию IUnknown — CUnknown — повторно. Если CA наследует и CUnknown, и IUnknown, он по-прежнему обязан реализовать чисто виртуальные функции IUnknown.

Теперь предположим, что CA наследует IUnknown и через CUnknown, и через IX. Поскольку IX не реализует функции-члены IUnknown, они по-прежнему остаются абстрактными, и CA обязан их реализовать. В данном случае реализация функций в CA скрыла бы их реализацию в CUnknown. Во избежание этой проблемы наш CUnknown реализует INondelegatingUnknown. Правильный вариант изображен на рис. 9-3.

NondelegatingUnknown IUnknown IX CUnknown NondelegatingQueryInterface NondelegatingAddRef NondelegatingRelease Внешний IUnknown CA передает вызовы либо неделегирующей версии QueryInterface в CUnknown, либо AddRef DECLARE_IUNKNOWN внешнему компоненту в зависимости от Release конретной ситуации Рис. 9-3 Наследуемый CUnknown не реализует интерфейс IUnknown, наследуемый от IX. Вместо этого CUnknown реализует INondelegatingUnknown. Сам компонент реализует IUnknown Функция GetOuterUnknown Представленная в листинге 9-3 реализация DECLARE_IUNKNOWN использует функцию CUnknown::

GetOuterUnknown, которая возвращает указатель на IUnknown. Если компонент наследует CUnknown и не агрегируется, GetOuterUnknown возвращает указатель на интерфейс INondelegatingUnknown этого компонента.

Если компонент агрегируется, эта функция возвращает указатель на интерфейс IUnknown внешнего компонента.

Всякий раз, когда компоненту нужен указатель IUnknown, он использует GetOuterUnknown.

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

Конструктор CUnknown Что касается внешнего IUnknown, конструктор CUnknown принимает указатель на него в качестве параметра и сохраняет для последующего использования функцией GetOuterUnknown. Конструкторы классов, производных от CUnknown, должны также принимать указатель на внешний IUnknown и передавать его конструктору CUnknown.

Функции Init и FinalRelease CUnknown поддерживает две виртуальные функции, которые помогают производным классам управлять внутренними компонентами. Чтобы создать компоненты для агрегирования или включения, производные классы переопределяют функцию Init. CUnknown::Init вызывается CFactory::CreateInstance сразу после создания компонента. CUnknown::FinalRelease вызывается из CUnknown::NondelegatingRelease непосредственно перед удалением компонента. Это дает компоненту возможность освободить имеющиеся у него указатели внутренних компонентов. CUnknown::FinalRelease увеличивает счетчик ссылок во избежание рекурсивных вызовов Release, когда компонент освобождает интерфейсы содержащихся в нем компонентов.

Скоро Вы увидите, как просто реализовать компонент с помощью CUnknown. Но сначала давайте рассмотрим класс CFactory, который упрощает регистрацию и создание компонентов.

Базовый класс CFactory Когда компонент реализован, необходимо создать для него фабрику класса. В предыдущих главах мы реализовывали фабрику класса заново для каждого компонента. В этой главе фабрика класса будет заранее реализована классом С++ CFactory. CFactory не только реализует интерфейс IClassFactory, он также предоставляет код, который можно использовать при реализации точек входа DLL, таких как DllGetClassObject.

Кроме того, CFactory поддерживает размещение нескольких компонентов в одной DLL. Все такие компоненты будут совместно использовать одну реализацию IClassFactory. (Мы уже кратко рассматривали этот вариант в гл.

7.) CFactory можно использовать с любым компонентом, который удовлетворяет следующим трем требованиям:

Компонент должен реализовывать функцию создания, имеющую прототип:

HRESULT CreateFunction(IUnknown* pUnknownOuter, CUnknown** ppNewComponent) Универсальная реализация IClassFactory::CreateInstance должна иметь универсальный способ создания компонентов.

Компонент должен наследовать CUnknown.

Реализация IClassFactory::CreateInstance в CFactory после создания компонента вызывает CUnknown::Init. Компонент может переопределить этот метод для выполнения дополнительной инициализации, например, чтобы создать другой компонент для включения или агрегирования.

Компонент должен заполнить структуру CfactoryData и поместить ее в глобальный массив g_FactoryDataArray.

Замечу, что данные требования не имеют никакого отношения к СОМ. Они обусловлены выбранным мною способом реализации CFactory. Давайте более подробно рассмотрим первое и последнее требования.

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

HRESULT CreateFunction(IUnknown* pUnknownOuter, CUnknown** ppNewComponent) Обычно такая функция создания вызывает конструктор компонента и затем возвращает указатель на новый компонент через выходной параметр ppNewComponent. Если первый параметр — pUnknownOuter — не равен NULL, то компонент агрегируется.

Я предпочитаю делать эту функцию статическим членом класса, реализующего компонент. Благодаря этому она оказывается в том же пространстве имен (name space), что и компонент. За исключением прототипа, эта функция может быть реализована аналогично функции CreateInstance предыдущих глав.

Данные компонента для CFactory CFactory необходимо знать, какие компоненты он может создавать. Глобальный массив с именем g_FactoryDataArray содержит информацию об этих компонентах. Элементы массива g_FactoryDataArray — это классы CfactoryData. CfactoryData объявлен так:

typedef HRESULT (*FPCREATEINSTANCE)(IUnknown*, CUnknown**);

class CFactoryData { public:

// Идентификатор класса компонента const CLSID* m_pCLSID;

// Указатель на функцию, создающую компонент FPCREATEINSTANCE CreateInstance;

// Имя компонента для регистрации в Реестре const char* m_RegistryName;

// ProgID const char* m_szProgID;

// Не зависящий от версии ProgID const char* m_szVerIndProgID;

// Вспомогательная функция для поиска по идентификатору класса BOOL IsClassID(const CLSID& clsid) const { return (*m_pCLSID == clsid);

} };

CFactoryData имеет пять полей: идентификатор класса компонента, указатель функции создания компонента, дружественное имя для записи в Реестр Windows, ProgID и независимый от версии ProgID. В классе также имеется вспомогательная функция для поиска по идентификатору класса. Как видно из листинга 9-4, где показан файл SERVER.CPP, заполнить структуру CFactoryData нетрудно.

SERVER.CPP #include "CFactory.h" #include "Iface.h" #include "Cmpnt1.h" #include "Cmpnt2.h" #include "Cmpnt3.h" /////////////////////////////////////////////////////////// // // Server.cpp // // Код сервера компонента.

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

// // Каждый производный от CUnknown компонент определяет // для своего создания статическую функцию со следующим прототипом:

// HRESULT CreateInstance(IUnknown* pUnknownOuter, // CUnknown** ppNewComponent);

// Эта функция вызывается при создании компонента.

// // // Следующий далее массив содержит данные, используемые CFactory // для создания компонентов. Каждый элемент массива содержит CLSID, // указатель на функцию создания и имя компонента для помещения в // Реестр.

// CFactoryData g_FactoryDataArray[] = { {&CLSID_Component1, CA::CreateInstance, "Inside COM, Chapter 9 Example, Component 1", // Дружественное имя "InsideCOM.Chap09.Cmpnt1.1", // ProgID "InsideCOM.Chap09.Cmpnt1"}, // Не зависящий от версии // ProgID {&CLSID_Component2, CB::CreateInstance, "Inside COM, Chapter 9 Example, Component 2", "InsideCOM.Chap09.Cmpnt2.1", "InsideCOM.Chap09.Cmpnt2"}, {&CLSID_Component3, CC::CreateInstance, "Inside COM, Chapter 9 Example, Component 3", "InsideCOM.Chap09.Cmpnt3.1", "InsideCOM.Chap09.Cmpnt3"} };

int g_cFactoryDataEntries = sizeof(g_FactoryDataArray) / sizeof(CFactoryData);

Листинг 9-4 Для того, чтобы использовать фабрику класса, Вы должны создать массив g_FactoryDataArray и поместить в него структуру CFactoryData для каждого компонента В листинге 9-4 элементы g_FactoryDataArray инициализированы информацией о трех компонентах, которые будет обслуживать данная DLL.

CFactory использует массив g_FactoryDataArray, чтобы определить, какие компоненты он может создавать. Если компонент присутствует в этом массиве, CFactory может его создать. CFactory получает из этого массива указатель на функцию создания компонента. Кроме того, CFactory использует информацию из CFactoryData для регистрации компонента. На рис. 9-4 показана структура сервера компонентов в процессе, реализованного с помощью CFactory.

CFACTORY.CPP Компонент CFactory DllGetClassObject IClassFactory CreateInstance DllRegisterServer DllUnregisterServer IX DllCanUnloadNow SERVER.CPP Компонент g_FactoryDataArray[] CreateInstance CFactoryData CFactoryData IX Рис. 9-4 Организация CFactoryData Файл CFACTORY.H реализует различные точки входа DLL при помощи вызова функций CFactory.

DllGetClassObject вызывает статическую функцию CFactory::GetClassObject, и та обыскивает в глобальном массиве g_FactoryDataArray структуру CfactoryData, соответствующую компоненту, которого хочет создать клиент. Массив g_FactoryDataArray определен в SERVER.CPP и содержит информацию о всех компонентах, поддерживаемых данной DLL. CFactory::GetClassObject создает для компонента фабрику класса и передает последней структуру CfactoryData, соответствующую компоненту.

После создания компонента CFactory вызывается реализация IClassFactory::CreateInstance, которая для создания компонента использует указатель на функцию создания экземпляра, хранящийся в CfactoryData. Код CFactory::GetClassObject и CFactory::CreateInstance представлен в листингах 9-5 и 9-6.

Реализация GetClassObject в CFACTORY.CPP /////////////////////////////////////////////////////////// // // GetClassObject // - Создание фабрики класса по заданному CLSID // HRESULT CFactory::GetClassObject(const CLSID& clsid, const IID& iid, void** ppv) { if ((iid != IID_IUnknown) && (iid != IID_IClassFactory)) { return E_NOINTERFACE;

} // Поиск идентификатора класса в массиве for (int i = 0;

i < g_cFactoryDataEntries;

i++) { const CFactoryData* pData = &g_FactoryDataArray[i];

if (pData->IsClassID(clsid)) { // Идентификатор класса найден в массиве компонентов, // которые мы можем создать. Поэтому создадим фабрику // класса для данного компонента. Чтобы задать фабрике // класса тип компонентов, которые она должна создавать, // ей передается структура CFactoryData *ppv = (IUnknown*) new CFactory(pData);

if (*ppv == NULL) { return E_OUTOFMEMORY;

} return NOERROR;

} } return CLASS_E_CLASSNOTAVAILABLE;

} Листинг 9-5 Реализация CFactory::GetClassObject Реализация CreateInstance в CFACTORY.CPP HRESULT stdcall CFactory::CreateInstance(IUnknown* pUnknownOuter, const IID& iid, void** ppv) { // При агрегировании IID должен быть IID_IUnknown if ((pUnknownOuter != NULL) && (iid != IID_IUnknown)) { return CLASS_E_NOAGGREGATION;

} // Создать компонент CUnknown* pNewComponent;

HRESULT hr = m_pFactoryData->CreateInstance(pUnknownOuter, &pNewComponent);

if (FAILED(hr)) { return hr;

} // Initialize the component.

hr = pNewComponent->Init();

if (FAILED(hr)) { // Ошибка инициализации. Удалить компонент pNewComponent->NondelegatingRelease();

return hr;

} // Получить запрошенный интерфейс hr = pNewComponent->NondelegatingQueryInterface(iid, ppv);

// Освободить ссылку, удерживаемую фабрикой класса pNewComponent->NondelegatingRelease();

return hr;

} Листинг 9-6 Реализация CFactory::CreateInstance Вот и все тонкости создания компонентов с помощью CFactory. Реализуйте компонент и поместите его данные в структуру — это все!

Использование CUnknown и CFactory Я очень рад, что теперь мы сможем повторно использовать реализацию интерфейс IUnknown и фабрики класса.

Вам наверняка уже надоел один и тот же код QueryInterface, AddRef и Release. Я тоже устал от него. Отныне наши компоненты не будут реализовывать AddRef и Release, а будут лишь добавлять поддержку нужных интерфейсов в QueryInterface. Мы также сможем использовать простую функцию создания, а не писать заново целую фабрику класса. Наши новые клиенты будут похожи на клиент, представленный в листинге 9-7.

CMPNT2.H // // Cmpnt2.h - Компонент // #include "Iface.h" #include "CUnknown.h"// Базовый класс для IUnknown /////////////////////////////////////////////////////////// // // Компонент B // class CB : public CUnknown, public IY { public:

// Создание static HRESULT CreateInstance(IUnknown* pUnknownOuter, CUnknown** ppNewComponent);

private:

// Объявление делегирующего IUnknown DECLARE_IUNKNOWN // Неделегирующий IUnknown virtual HRESULT stdcall NondelegatingQueryInterface(const IID& iid, void** ppv);

// Интерфейс IY virtual void stdcall Fy();

// Инициализация virtual HRESULT Init();

// Очистка virtual void FinalRelease();

// Конструктор CB(IUnknown* pUnknownOuter);

// Деструктор ~CB();

// Указатель на внутренний агрегируемый объект IUnknown* m_pUnknownInner;

// Указатель на интерфейс IZ, поддерживаемый внутренним компонентом IZ* m_pIZ;

};

Листинг 9-7 Компонент, использующий IUnknown, реализованный в CUnknown В листинге 9-7 представлен заголовочный файл для Компонента 2 из примера этой главы. Код мы рассмотрим чуть позже. В этом примере Компонент 1 реализует интерфейс IX самостоятельно. Для того, чтобы предоставить интерфейсы IY и IZ, он агрегирует Компонент 2. Компонент 2 реализует IY и агрегирует Компонент 3, который, в свою очередь, реализует IZ. Таким образом, Компонент 2 — одновременно и агрегируемый, и агрегирующий.

Посмотрим листинг 9-7 от начала до конца. Я отмечу все интересные моменты, а затем мы рассмотрим их подробно.

Компонент наследует CUnknown, который предоставляет реализацию IUnknown. Мы объявляем статическую функцию, которую CFactory будет использовать для создания компонента. Имя этой функции для CFactory не имеет значения, поэтому можно назвать ее как угодно.

Далее мы реализуем делегирующий IUnknown с помощью макроса DECLARE_IUNKNOWN.

DECLARE_IUNKNOWN реализует делегирующий IUnknown, а CUnknown — неделегирующий.

Хотя CUnknown полностью реализует AddRef и Release, он не может предоставить полной реализации QueryInterface, так как ему неизвестно, какие интерфейсы поддерживает наш компонент. Поэтому компонент реализует NondelegatingQueryInterface для обработки запросов на его собственные интерфейсы.

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

Теперь рассмотрим различные аспекты Компонента 2, код которого представлен в листинге 9-8.

CMPNT2.CPP // // Cmpnt2.cpp - Компонент // #include #include "Iface.h" #include "Util.h" #include "CUnknown.h"// Базовый класс для IUnknown #include "Cmpnt2.h" static inline void trace(char* msg) { Util::Trace("Компонент 2", msg, S_OK);

} static inline void trace(char* msg, HRESULT hr) { Util::Trace("Компонент 2", msg, hr);

} /////////////////////////////////////////////////////////// // // Реализация интерфейса IY // void stdcall CB::Fy() { trace("Fy");

} // // Конструктор // CB::CB(IUnknown* pUnknownOuter) : CUnknown(pUnknownOuter), m_pUnknownInner(NULL), m_pIZ(NULL) { // Пустой } // // Деструктор // CB::~CB() { trace("Самоликвидация");

} // // Реализация NondelegatingQueryInterface // HRESULT stdcall CB::NondelegatingQueryInterface(const IID& iid, void** ppv) { if (iid == IID_IY) { return FinishQI(static_cast(this), ppv);

} else if (iid == IID_IZ) { return m_pUnknownInner->QueryInterface(iid, ppv);

} else { return CUnknown::NondelegatingQueryInterface(iid, ppv);

} } // // Инициализировать компонент и создать внутренний компонент // HRESULT CB::Init() { trace("Создание агрегируемого Компонента 3");

HRESULT hr = CoCreateInstance(CLSID_Component3, GetOuterUnknown(), CLSCTX_INPROC_SERVER, IID_IUnknown, (void**)&m_pUnknownInner);

if (FAILED(hr)) { trace("Не могу создать внутренний компонент", hr);

return E_FAIL;

} trace("Получить указатель на интерфейс IZ для использования в дальнейшем");

hr = m_pUnknownInner->QueryInterface(IID_IZ, (void**)&m_pIZ);

if (FAILED(hr)) { trace("Внутренний компонент не поддерживает IZ", hr);

m_pUnknownInner->Release();

m_pUnknownInner = NULL;

return E_FAIL;

} // Компенсировать увеличение счетчика ссылок из-за вызова QI trace("Указатель на интерфейс IZ получен. Освободить ссылку.");

GetOuterUnknown()->Release();

return S_OK;

} // // FinalRelease – Вызывается из Release перед удаление компонента // void CB::FinalRelease() { // Вызов базового класса для увеличения m_cRef и предотвращения рекурсии CUnknown::FinalRelease();

// Учесть GetOuterUnknown()->Release в методе Init GetOuterUnknown()->AddRef();

// Корректно освободить указатель, так как подсчет ссылок // может вестись поинтерфейсно m_pIZ->Release();

// Освободить внутренний компонент // (Теперь мы можем это сделать, так как освободили его интерфейсы) if (m_pUnknownInner != NULL) { m_pUnknownInner->Release();

} } /////////////////////////////////////////////////////////// // // Функция создания для CFactory // HRESULT CB::CreateInstance(IUnknown* pUnknownOuter, CUnknown** ppNewComponent) { *ppNewComponent = new CB(pUnknownOuter);

return S_OK;

} Листинг 9-8 Реализация компонента, использующего CUnknown и CFactory NondelegatingQueryInterface Вероятно, самая интересная часть компонента — NondelegatingQueryInterface. Мы реализуем ее почти так же, как QueryInterface в предыдущих главах. Обратите, однако, внимание на два отличия. Во-первых, мы используем функцию FinishQI, причем делаем это лишь для удобства;

мы не обязаны ее использовать. FinishQI лишь несколько облегчает реализацию NondeletgatingQueryInterface в производных классах. Код этой функции показан ниже:

HRESULT CUnknown::FinishQI(IUnknown* pI, void** ppv) { *ppv = pI;

pI->AddRef();

return S_OK;

} Второе отличие в том, что нам нет необходимости обрабатывать запрос на IUnknown. Базовый класс выполняет обработку для IUnknown и всех интерфейсов, о которых мы не знаем:

HRESULT stdcall CUnknown::NondelegatingQueryInterface(const IID& iid, void** ppv) { // CUnknown поддерживает только IUnknown if (iid == IID_IUnknown) { return FinishQI(reinterpret_cast (static_cast(this)), ppv);

} else { *ppv = NULL;

return E_NOINTERFACE;

} } Все вместе, шаг за шагом Приведенный выше код показывает, как легко писать компоненты с помощью CUnknown и CFactory. Давайте рассмотрим всю процедуру целиком. Далее приводится последовательность шагов создания компонента, его фабрики класса и DLL, в которой он будет находиться:

1. Напишите класс, реализующий компонент.

Базовым классом компонента должен быть либо CUnknown, либо другой класс, производный от него.

При помощи макроса DECLARE_IUNKNOWN реализуйте делегирующий IUnknown.

Инициализируйте CUnknown в конструкторе своего класса.

Реализуйте NondelegatingQueryInterface, добавив интерфейсы, которые поддерживает Ваш класс, но не поддерживает базовый класс. Вызовите базовый класс для тех интерфейсов, которые не обрабатываются в Вашем классе.

Если Ваш компонент требует дополнительной инициализации после конструктора, реализуйте функцию Init. Создайте включаемые и агрегируемые компоненты, если это необходимо.

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

Реализуйте для своего компонента статическую функцию CreateInstance.

Реализуйте поддерживаемые компонентом интерфейсы.

2. Повторите шаг 1 для каждого из компонентов, которые Вы хотите поместить в данную DLL.

3. Напишите фабрику класса.

Создайте файл для определения глобального массива CfactoryData — g_FactoryDataArray.

Определите g_FactoryDataArray и поместите в него информацию о всех компонентах, обслуживаемых этой DLL.

Определите g_cFactoryDataEntries, которая должна содержать число компонентов в массиве g_FactoryDataArray.

4. Создайте DEF файл с описанием точек входа в DLL.

5. Скомпилируйте и скомпонуйте свою программу вместе с файлами CUNKNOWN.CPP и CFACTORY.CPP.

6. Пошлите мне в знак благодарности открытку с изображением водопада или речного порога.

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

Резюме При использовании класса smart-указателей, скрывающих подсчет ссылок, работа с компонентами СОМ становится похожей на работу с классами С++. Кроме того, применение smart-указателей помогает уменьшить число ошибок, поскольку обеспечивает безопасное в смысле приведения типов получение указателей на интерфейсы. Многие классы smart-указателей на интерфейсы переопределяют operator=, чтобы вызывать QueryInterface при присваивании указателя на интерфейс одного типа указателю на интерфейс другого типа.

Если smart-указатели облегчают работу с объектами СОМ, то некоторые классы С++ делают ее максимально простой. Классы CUnknown и CFactory упрощают создание компонентов СОМ, предоставляя повторно применимые реализации IUnknown и IClassFactory.

Учитывая всеобщее стремление до предела все упростить, я удивлюсь, если после этой главы Вам не станет легче дышать. Да, чуть не забыл — есть компания, производящая устройство для облегчения дыхания, вставляемое в нос. Некоторые велосипедисты-профессионалы его используют.

Я полагаю, немного помощи не повредит, когда Вы делаете что-то новое.

10 глава Серверы в EXE В последний раз я был в Берлине еще до падения стены. Когда, покидая американский сектор у пропускного поста «Чекпойнт Чарли», я въезжал в Восточный Берлин, не возникало сомнений, что здесь проходит граница.

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

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

Почему нам нужно выходить за границу процесса? Потому, что в некоторых случаях предпочтительнее реализовать компонент в EXE, а не в DLL. Одной из причин может стать то, что Ваше приложение уже реализовано в EXE. После небольшой доработки можно сделать доступными сервисы приложения, так что клиенты смогут автоматизировать его использование.

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

Разные процессы Каждый модуль EXE исполняется в отдельном процессе. У каждого процесса есть свое адресное пространство.

Логический адрес 0x0000ABBA в двух разных процессах ссылается на два разных места в физической памяти.

Если один процесс передаст этот адрес другому, второй будет работать не с тем участком памяти, который предполагался первым процессом (рис. 10-1).

В то время как каждому EXE-модулю соответствует свой процесс, DLL проецируется в процесс того EXE, с которым они скомпонованы. По этой причине DLL называют серверами внутри процесса (in process), а EXE — серверами вне процесса (out of process). Иногда EXE также называют локальными серверами, чтобы отличить их от другого вида серверов вне процесса — удаленных серверов. Удаленный сервер — это сервер вне процесса, работающий на другой машине.

Адресное пространство Физическая память процесса Процесс pFoo 0x0000ABBA 0x Адресное пространство процесса Процесс pFoo 0x0000ABBA 0x0BAD0ADD Рис. 10-1 Один и тот же адрес в двух разных процессах ссылается на два разных участка физической памяти В гл. 5 мы говорили, как важно то, что компонент и клиент используют общее адресное пространство. Компонент передает клиенту интерфейс. Интерфейс — это, по существу, массив указателей функций. Клиент должен иметь доступ к памяти, занимаемой интерфейсом. Если компонент находится в DLL, то доступ осуществляется легко: и компонент, и клиент находятся в одном адресном пространстве. Но если компонент и клиент находятся в разных адресных пространствах, то у клиента нет доступа к памяти процесса компонента. Если у клиента нет даже доступа к памяти, связанной с интерфейсом, то он не сможет вызывать и функции этого интерфейса. В такой ситуации наши интерфейсы стали бы совершенно бесполезны.

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

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

Процесс должен иметь возможность передавать другому процессу данные.

Клиент не должен беспокоиться о том, является ли компонент сервером внутри или вне процесса.

Локальный вызов процедуры Есть много методов межпроцессной коммуникации, включая DDE, именованные каналы и разделяемую память.

Однако СОМ использует локальный вызов процедуры (local procedure call, LPC). LPC — это средство связи между разными процессами на одной и той же машине. LPC представляет собой специализированное средство связи между разными процессами в пределах одной машины, построенное на основе удаленного вызова процедуры (remote procedure call, RPC) (см. рис. 10-2).

Стандарт RPC определен OSF (Open Software Foundation) в спецификации DCE (Distributed Computing Environment) RPC. RPC обеспечивает коммуникацию между процессами на разных машинах с помощью разнообразных сетевых протоколов. Распределенная модель СОМ (DCOM), которую мы будем рассматривать далее в этой главе, использует RPC для связи по сети.

Как работает RPC? Как по волшебству. На самом деле волшебства, конечно, нет, но есть кое-что, что лишь немногим хуже, — реализация вызовов операционной системой. Операционной системе известны физические адреса, соответствующие логическому адресному пространству каждого процесса;

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

EXE EXE Клиент Компонент Локальный вызов процедуры Рис. 10-2 Клиент в EXE использует механизм Win32 LPC для вызова функций компонента, реализованного в другом EXE Маршалинг Вызвать функцию EXE — это только полдела. Нам по-прежнему необходимо передать параметры функции из адресного пространства клиента в адресное пространство компонента. Этот процесс называется маршалингом (marshaling). В соответствии с моим словарем, глагол marshal значит «располагать, размещать или устанавливать в определенном порядке». Это слово должно быть в нашем ближайшем диктанте.

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

Механизм LPC способен скопировать данные из одного процесса в другой. Но для выборки параметров и посылки их в другой процесс ему требуется больше информации, чем содержится в заголовочном файле С++.

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

Для маршалинга компонента предназначен интерфейс IMarshal. В процессе создания компонента СОМ запрашивает у него этот интерфейс. Затем СОМ вызывает функции-члены этого интерфейса для маршалинга и демаршалинга параметров до и после вызова функций. Библиотека СОМ реализует стандартную версию IMarshal, которая работает для большинства интерфейсов. Основной причиной создания собственной версии Граница процесса IMarshal является стремление повысить производительность. Подробно маршалинг описан в книге Крейга Брокшмидта Inside OLE.

DLL заместителя/заглушки Неужели я потратил девять глав на обсуждение того, как вызывать компоненты СОМ через интерфейсы, чтобы в десятой начать вызывать их посредством LPC? С самого начала мы стремились унифицировать работу клиента с компонентами — внутри процесса, вне процесса и удаленными. Очевидно, что мы на достигли цели, если клиенту нужно заботиться о LPC. СОМ решает проблему просто.

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

СОМ использует весьма похожую структуру. Клиент взаимодействует с DLL, которая изображает собой компонент. Эта DLL выполняет за клиента маршалинг и вызовы LPC. В COM такой компонент называется заместителем (proxy).

В терминах СОМ, заместитель — это компонент, который действует как другой компонент. Заместители должны находиться в DLL, так как им необходим доступ к адресному пространству клиента для маршалинга данных, передаваемых ему функциями интерфейса. Но маршалинг — это лишь половина дела;

компоненту еще требуется DLL, называемая заглушкой (stub), для демаршалинга данных, переданных клиентом. Заглушка выполняет также маршалинг данных, возвращаемых компонентом обратно клиенту (рис. 10-3).

EXE EXE Клиент Компонент DLL DLL Заместитель Заглушка выполняет выполняет маршалинг демаршалинг Локальный вызов процедуры параметров параметров Рис. 10-3 Клиент работает с DLL заместителя. Заместитель выполняет маршалинг параметров фунции и вызывает DLL заглушки с помощью LPC. DLL заглушки выполняет демаршалинг параметров и вызывает соответствующую функцию компонента, передавая ей параметры.

Данный процесс изображен на рис. 10-3 весьма упрощенно. Однако рисунок дает представление о том, как много нужно кода, чтобы все это работало.

Забудьте об этом! Слишком много кода!

Итак, для размещения компонента в EXE нужно написать заместитель и заглушку. Кроме того, нужно разбираться в LPC, чтобы реализовать вызовы через границы процессов. Вдобавок нужно реализовать IMarshal для маршалинга данных от клиента компоненту и обратно. Кажется, для меня это слишком много… я лучше проведу это время, бросая камешки в воду… К счастью, всю работу нам делать не нужно — по крайней мере, в большинстве случаев.

Введение в IDL/MIDL Вероятно, Вам интереснее писать хорошие компоненты, чем кучу кода, предназначенного лишь для общения компонентов друг с другом. Я лучше займусь составлением программы OpenGL, чем кодом пересылки данных между двумя процессами. К счастью, мы не обязаны писать этот код сами. Задав описание интерфейса на языке IDL (Interface Definition Language), мы можем использовать компилятор MIDL для автоматической генерации DLL заместителя/заглушки.

Конечно, если Вы хотите сделать все сами, — пожалуйста. Одна из привлекательных черт СОМ в том, что эта модель предоставляет множество реализаций по умолчанию, но позволяет, если нужно, создать и свой собственный интерфейс. Но для большинства интерфейсов специализированный маршалинг не нужен, и Граница процесса большинству компонентов не требуются самодельные заместители и заглушки. Иначе говоря, будем использовать простой способ. Конечно, «простой» — понятие относительное, и от нас по-прежнему потребуются определенные усилия.

Язык IDL, так же как UUID и спецификация RPC, был заимствован из OSF DCE. Его синтаксис похож на С и С++, и он обладает богатыми возможностями описания интерфейсов и данных, используемых клиентом и компонентом. Хотя интерфейс СОМ использует только подмножество IDL, Microsoft потребовалось внести некоторые нестандартные расширения для поддержки СОМ. Мы в Microsoft всегда считаем, что стандарт можно улучшить.

После составления описания интерфейсов и компонентов на IDL это описание обрабатывается компилятором MIDL (компилятор IDL фирмы Microsoft). Последний генерирует код на С для DLL заместителя и заглушки.

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

IDL Хотя Вы и избавились от труда изучения LPC, Вам все равно необходимо научиться описывать интерфейсы на IDL. Это нетрудно, но может вызвать сильное разочарование — IDL непоследователен, документация плохая, хорошие примеры найти трудно, а сообщения об ошибках иногда загадочны. Мое любимое: «Попробуйте обойти ошибку» («Try to find a work around»). Поскольку IDL сохранит нам массу времени и усилий, мы не будем (долго) сетовать по этому поводу. Мой совет — потратить день и прочитать документацию IDL на компакт-диске MSDN.

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

У Вас может возникнуть искушение не использовать IDL, а сделать все самостоятельно. Но в следующей главе мы будем использовать компилятор MIDL для создания библиотек типа. Вы можете самостоятельно создавать и библиотеки типа, но такой подход не имеет никаких реальных преимуществ. Коротко говоря, гораздо лучше потратить время на изучение IDL, который сразу дает заместитель, заглушку и библиотеку типа.

Примеры описаний интерфейсов на IDL Давайте рассмотрим пример описания интерфейса на IDL. Ниже приведен фрагмент файла SERVER.IDL из примера гл. 10.

import “unknwn.idl”;

// Интерфейс IX [ object, uuid(32bb8323-b41b-11cf-a6bb-0080c7b2d682), helpstring(“IX Interface”), pointer_default(unique) ] interface IX : IUnknown { HRESULT FxStringIn([in, string] wchar_t* szIn);

HRESULT FxStringOut([out, string] wchar_t** szOut);

};

На С++ соответствующие функции выглядели бы так:

virtual HRESULT stdcall FxStringIn(wchar_t* szIn);

virtual HRESULT stdcall FxStringOut(wchar_t** szOut);

Как видите, синтаксис MIDL не очень отличается от синтаксиса С++. Самое очевидное отличие — информация в квадратных скобках ([]). Перед каждым интерфейсом идет список атрибутов, или заголовок интерфейса. В данном примере заголовок состоит из четырех записей. Ключевое слово object задает, что данный интерфейс является интерфейсом СОМ. Это ключевое слово представляет собой расширение IDL от Microsoft. Второе ключевое слово — uuid — задает IID интерфейса. Третье ключевое слово используется для помещения строки подсказки в библиотеку типа. Подождите, мы еще рассмотрим библиотеки типа в следующей главе, так как они связаны напрямую с серверами вне процесса. Четвертое ключевое слово — pointer_default — выглядит незнакомо и мы сейчас о нем поговорим.

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

Имеется три опции:

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

unique — эти указатели могут иметь значение NULL. Кроме того, их значение может изменяться при работе функции. Однако внутри функции для них нельзя создавать синонимы.

ptr — эта опция указывает, что по умолчанию указатель эквивалентен указателю С. Указатель может иметь синоним, может иметь значение NULL и может изменяться.

MIDL использует эти значения для оптимизации генерируемого кода заместителя и заглушки.

Входные и выходные параметры в IDL Для дальнейшей оптимизации заместителя и заглушки MIDL использует входные и выходные параметры (in и out). Если параметр помечен как входной, то MIDL знает, что этот параметр нужно передавать только от клиента компоненту. Заглушка не возвращает значение параметра обратно. Ключевое слово out говорит MIDL о том, что параметр используется только для возврата данных от компонента клиенту. Заместителю не нужно выполнять маршалинг выходного параметра и пересылать его значение компоненту.

Параметры могут быть также помечены обоими ключевыми словами одновременно:

HRESULT foo([in] int x, [in, out] int* y, [out] int* z);

В предыдущем фрагменте y является как входным, так и выходным параметром. Компилятор MIDL требует, чтобы выходные параметры были указателями.

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

Определить длину строки С++ легко — нужно найти завершающий ее символ с кодом 0. Если параметр функции имеет атрибут string, то MIDL знает, что этот параметр является строкой, и может указанным способом определить ее длину.

По стандартному соглашению СОМ использует для строки символы UNICODE, даже в таких системах, как Microsoft Windows 95, которые сами UNICODE не поддерживают. Именно по этой причине предыдущий параметр использует для строк тип wchar_t. Вместо wchar_t Вы также можете использовать OLECHAR или LPOLESTR, которые определены в заголовочных файлах СОМ.

HRESULT в IDL Вы, вероятно, заметили, что обе функции представленного выше интерфейса IX возвращают HRESULT. MIDL требует, чтобы функции интерфейсов, помеченные как object, возвращали HRESULT. Основная причина этого — требование поддержки удаленных серверов. Если Вы подключаетесь к удаленному серверу, любая функция может потерпеть неудачу из-за ошибки сети. Следовательно, у каждой функции должен быть способ сигнализации о сетевых ошибках. Для этого проще всего потребовать, чтобы все функции возвращали HRESULT.

Именно поэтому большинство функций СОМ возвращает HRESULT. (Многие пишут для интерфейсов СОМ классы-оболочки, которые генерируют исключение, если метод возвращает код ошибки. На самом деле компилятор Microsoft Visual C++ версии 5.0 может импортировать библиотеку типа и автоматически сгенерировать для ее членов классы-оболочки, который будут генерировать исключения при получении ошибочных HRESULT.) Если функции нужно возвращать параметр, отличный от HRESULT, следует использовать выходной параметр. Функция FxStringOut использует такой параметр для возврата компонентом строки. Эта функция выделяет память для строки при помощи CoTaskMemAlloc. Клиент должен освободить эту память при помощи CoTaskMemFree. Следующий пример из файла CLIENT.CPP гл. 10 демонстрирует использование определенного выше интерфейса.

wchar_t* szOut = NULL;

HRESULT hr = pIX->FxStringIn(L”Это тест”);

assert(SUCCEEDED(hr));

hr = pIX->FxStringOut(&szOut);

assert(SUCCEEDED(hr));

// Отобразить возвращенную строку ostrstream sout;

sout << “FxStringOut возвратила строку: ” << szOut // Использование переопределенного оператора << для типа wchar_t << ends;

trace(sout.str());

// Удалить возвращенную строку ::CoTaskMemFree(szOut);

Для освобождения памяти используется CoTaskMemFree.

Ключевое слово import в IDL Ключевое слово import используется для включения определений из других файлов IDL. UNKNWN.IDL содержит описание на IDL интерфейса IUnknown;

import является аналогом команды препроцессора С++ #include, но с помощью import файл можно импортировать сколько угодно раз, не создавая проблем с повторными определениями. Все стандартные интерфейсы СОМ и OLE (ActiveX) определены в файлах IDL (посмотрите в каталоге INCLUDE своего компилятора;

просматривать файлы IDL для стандартных интерфейсов OLE — хороший метод приобретения опыта описания интерфейсов).

Модификатор size_is в IDL Теперь рассмотрим интерфейс, передающий массивы между клиентом и компонентом:

// Интерфейс IY [ object, uuid(32bb8324-b41b-11cf-a6bb-0080c7b2d682), helpstring(“Интерфейс IY”), pointer_default(unique) ] interface IY : IUnknown { HRESULT FyCount([out] long* sizeArray);

HRESULT FyArrayIn([in] long sizeIn, [in, size_is(sizeIn)] long arrayIn[]);

HRESULT FyArrayOut([out, in] long* psizeInOut, [out, size_is(*psizeInOut)] long arrayOut[]);

};

У интерфейса тот же заголовок, что и раньше. Здесь нам интересен атрибут size_is. Одна из основных функций маршалинга состоит в копировании данных из одного места в другое. Следовательно, очень важно иметь информацию о размере данных. Если размер всегда фиксирован, проблем нет. Но если его можно определить только во время выполнения, задача становится несколько сложнее. Если мы передаем функции массив, каким образом заместитель определит его размер?

Именно для этого и предназначен атрибут size_is. Для функции FyArrayIn этот атрибут сообщает MIDL, что число элементов массива хранится в sizeIn. Аргументом size_is может быть только входной параметр или параметр типа вход-выход. (in-out). Использование параметра вход-выход с атрибутом size_is демонстрирует другая функция интерфейса IY — FyArrayOut.

В качестве второго параметра клиент передает массив, для которого он уже выделил память. Количество элементов массива передается в первом параметре psizeInOut. Функция заполняет массив некоторыми данными.

Затем она заносит в psizeInOut число элементов, которые фактически возвращает.

По правде сказать, я не очень люблю параметры типа вход-выход и никогда не создаю интерфейсы, подобные только что приведенному. Вместо этого я определил бы отдельный выходной параметр (out) для возвращения компонентом числа заполненных элементов массива:

HRESULT FyArrayOut2([in] long sizeIn, [out, size_is(sizeIn)] long arrayOut[], [out] long* psizeOut);

Приведенный ниже код — фрагмент файла CLIENT.CPP из примера гл. 10. Здесь интерфейс IY сначала используется для передачи массива компоненту, а затем для возвращения его обратно.

// Послать массив компоненту long arrayIn[] = { 22, 44, 206, 76, 300, 500 };

long sizeIn = sizeof(arrayIn) / sizeof(arrayIn[0]);

HRESULT hr = pIY->FyArrayIn(sizeIn, arrayIn);

assert(SUCCEEDED(hr));

// Получить массив от компонента обратно // Получить размер массива long sizeOut = 0;

hr = pIY->FyCount(&sizeOut);

assert(SUCCEEDED(hr));

// Выделить память для массива long* arrayOut = new long[sizeOut];

// Получить массив hr = pIY->FyArrayOut(&sizeOut, arrayOut);

assert(SUCCEEDED(hr));

// Отобразить массив, возращенный функцией ostrstream sout;

sout << “FyArray вернула ” << sizeOut << “ элементов: ”;

for (int i = 0;

i < sizeOut, i++) { sout << “ ” << arrayOut[i];

} sout << “.” << ends;

trace(sout.str());

// Очистка delete [] arrayOut;

Технически, в соответствии со спецификацией СОМ, память для параметров типа out необходимо выделять с помощью CoTaskMemAlloc. Но многие интерфейсы СОМ эту функцию не используют. Наиболее близкий к IY::FyArrayOut пример — IxxxxENUM::Next, которая также не использует CoTaskMemAlloc. Самое странное в библиотеке СОМ то, что некоторые ее функции используют CoTaskMemAlloc, а некоторые нет. И по документации трудно отнести функцию к тому или другому классу: например, сравните документацию функций StringFromCLSID и StringFromGUID2. Какая из них требует освобождения памяти с помощью CoTaskMemFree?

Если Вы не знаете — ответ в гл. 6.

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

// Структура для интерфейса IZ typedef struct { double x;

double y;

double z;

} Point3d;

// Интерфейс IZ [ object, uuid(32bb8325-b41b-11cf-a6bb-0080c7b2d682), helpstring(“Интерфейс IZ”), pointer_default(unique) ] interface IZ : IUnknown { HRESULT FzStructIn([in] Point3d pt);

HRESULT FzStructOut([in] Point3d* pt);

};

И здесь IDL очень похож на C++. Дело усложняется, если Вы передаете непростые структуры, содержащие указатели. MIDL необходимо точно знать, на что каждый из них указывает, чтобы выполнить маршалинг данных, на которые имеется ссылка. Поэтому не используйте в качестве типа параметра void*. Если Вам нужно передать абстрактный указатель на интерфейс, используйте IUnknown*. Самый гибкий метод — передача клиентом IID, и именно так работает QueryInterface:

HRESULT GetIFace([in] const IID& iid, [out, iid_is(iid)] IUnknown** ppi);

Здесь атрибут iid_is используется для указания MIDL идентификатора интерфейса. Конечно, вместо этого можно было бы использовать:

HRESULT GetMyInterface([out] IMyInterface** pIMy);

Но что произойдет, если будет возвращен IMy2 или IMyNewAndVastlyImproved?

Компилятор MIDL Теперь, когда у нас есть файл IDL, его можно пропустить через компилятор MIDL, который сгенерирует несколько файлов. Если описания наших интерфейсов находятся в файле FOO.IDL, то скомпилировать этот файл можно следующей командой:

midl foo.idl В результате будут сгенерированы файлы, перечисленные в табл. 10-1.

Таблица 10-1 Файлы, гененрируемые компилятором MIDL Имя файла Содержимое FOO.H Заголовочный файл (для С и С++), содержащий объявления всех интерфейсов, описанных в файле IDL. Имя заголовочного файла можно изменить с помощью параметра командной строки /header или /h.

FOO_I.C Файл С, в котором определены все GUID, использованные в файле IDL. Имя файла можно изменить с помощью параметра командной строки /iid.

FOO_P.C Файл С, реализующий код заместителей и заглушек для всех описанных в файле IDL интерфейсов. Имя файла можно изменять с помощью параметра командной строки /proxy.

DLLDATA.C Файл С, реализующий DLL, которая содержит код заместителей и заглушек. Имя файла можно изменить с помощью параметра командной строки /dlldata.

Если в файле IDL имеется ключевое слово library, то по приведенной выше команде будет сгенерирована библиотека типа. (Как Вы помните, более подробно библиотеки типа будут рассматриваться в восхитительной следующей главе этой книги.) На рис. 10-4 показаны файлы, генерируемые компилятором MIDL. Здесь также показано, как из этих файлов генерируется DLL заместителя, — процесс, который мы рассмотрим чуть ниже.

FOO.H Эти файлы генерируются MIDL FOO_P.C FOO_I.C DLLDATA.C Компилятор C FOO.IDL MIDL.EXE и FOO.DLL компоновщик make-файл REGSVR32.EXE FOO.DEF Эти файлы пишете Вы Файл определений для DLL Рис. 10-4 Получение и использование файлов, генерируемых компилятором MIDL Сборка примера программы Чтобы наш разговор был более предметным, давайте соберем пример программы для этой главы. Все необходимые файлы есть на прилагающемся к книге компакт-диске. С помощью make-файла примера можно построить две версии сервера компонента: SERVER.DLL и SERVER.EXE. Для того, чтобы построить обе версии сразу, используется команда nmake –f makefile MAKEFILE дважды вызывает файл MAKE-ONE для сборки двух разных версий сервера. Промежуточные файлы сервера внутри процесса будут помещены в подкаталог \INPROC. Промежуточные файлы сервера вне процесса будут помещены в подкаталог \OUTPROC.

В make-файлах этого примера для запуска MIDL используется следующая командная строка:

midl /h iface.h /iid guids.c /proxy proxy.c server.idl Эта команда переименовывает файлы, генерируемые MIDL, чтобы мы могли использовать прежние имена.

Вместо того, чтобы писать определения интерфейса и в IFACE.H, и в SERVER.IDL, мы создаем только SERVER.IDL, а компилятор MIDL по нему генерирует IFACE.H автоматически. Точно так же нам более нужны GUID в файле GUID.CPP. Теперь мы просто подключаем GUIDS.C.

Заголовочный файл, генерируемый MIDL, можно использовать в программах как на С, так и на С++.

Единственный недостаток этих заголовочных файлов в том, что они практически нечитабельны. Вы поймете, что имеется в виду, если посмотрите на содержимое сгенерированного MIDL файла IFACE.H. Как видите, его нелегко расшифровать. Тем не менее, это гораздо лучше, чем вручную поддерживать одинаковые описания интерфейса в разных местах.

Сборка DLL заместителя Чтобы получить DLL заместителя/заглушки, нужно откомпилировать и скомпоновать файлы C, сгенерированные MIDL. Компилятор MIDL генерирует для нас код на С, который реализует для наших интерфейсов заместители и заглушки. Однако мы по-прежнему должны сами скомпилировать эти файлы в DLL. Первый шаг — написать для DLL заглушку файла DEF. Это очень просто. Файл DEF, который я использую, приведен ниже.

LIBRARY Proxy.dll DESCRIPTION ‘Proxy/Stub DLL’ EXPORTS DllGetClassObject @1 PRIVATE DllCanUnloadNow @2 PRIVATE GetProxyDllInfo @3 PRIVATE DllRegisterServer @4 PRIVATE DllUnregisterServer @5 PRIVATE Теперь осталось все это откомпилировать и скомпоновать. Как это сделать, показывает следующий фрагмент файла MAKE-ONE:

iface.h server.tlb proxy.c guids.c dlldata.c : server.idl midl /h iface.h /iid guids.c /proxy proxy.c server.idl !IF “$(OUTPROC)” != “” dlldata.obj : dlldata.c cl /c /DWIN32 /DREGISTER_PROXY_DLL dlldata.c proxy.obj : proxy.c cl /c /DWIN32 /DREGISTER_PROXY_DLL proxy.c PROXYSTUBOBJS = dlldata.obj \ proxy.obj \ guids.obj PROXYSTUBLIBS = kernel.lib \ rpcndr.lib \ rpcns4.lib \ rpcrt4.lib \ uuid.lib proxy.dll : $(PROXYSTUBOBJS) proxy.def link /dll /out:proxy.dll /def:proxy.def \ $(PROXYSTUBOBJS) $(PROXYSTUBLIBS) regsvr32 /s proxy.dll Регистрация DLL заместителя/заглушки Обратите внимание, что код make-файла определяет символ REGISTER_PROXY_DLL при компиляции файлов DLLDATA.C и PROXY.C. В результате генерируется код, позволяющий DLL заместителя/заглушки выполнять саморегистрацию. Затем, после компоновки DLL заместителя, make-файл регистрирует ее. Тем самым гарантируется, что Вы не забудете зарегистрировать DLL заместителя. Если бы Вы забыли это сделать, то несколько часов удивлялись бы, отчего вдруг не работает программа. Я это испытал.

Что именно DLL заместителя/заглушки помещает в Реестр? Давайте рассмотрим наш пример. Убедитесь, что Вы скомпоновали программу;

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

Теперь давайте запустим старый верный REGEDIT.EXE и посмотрим на раздел Реестра:

HKEY_CLASSES_ROOT\ Interface\ {32BB8323-B41B-11CF-A6BB-0080C7B2D682} Приведенный выше GUID — это IID интерфейса IX. В этом разделе содержится несколько записей. Самая для нас интересная — ProxyStubClsid32. В этом разделе содержится CLSID DLL заместителя/заглушки интерфейса;

для интерфейсов IX, IY и IZ он совпадает. Если найдете этот CLSID в разделе HKEY_CLASSES_ROOT\CLSID, там можно обнаружить и подраздел InprocServer32, который указывает на PROXY.DLL. Как видите, интерфейсы регистрируются независимо от реализующих их компонентов (рис. 10-5).

HKEY_CLASSES_ROOT CLSID {32BB8323-B41B-11CF-A6BB-0080C7B2D682} PSFactoryBuffer InprocServer32 C:\Chap10\proxy.dll Interface {32BB8323-B41B-11CF-A6BB-0080C7B2D682} IX ProxyStubClsid32 {32BB8323-B41B-11CF-A6BB-0080C7B2D682} Рис. 10-5 Структура информации, добавляемой в Реестр кодом заместителя/заглушки, сгенерированным MIDL При помощи MIDL мы можем вызывать функции и выполнять маршалинг параметров через границы процессов — и все будет выглядеть так же, как и при вызове компонента внутри процесса.

Реализация локального сервера Теперь пришло время рассмотреть изменения в CFactory, необходимые для поддержки серверов вне процесса.

Всякий раз, пересекая границу, Вы должны быть готовы изменить свои привычки и поведение, чтобы соответствовать местным обычаям. Точно так же обслуживание компонента из EXE отличается от обслуживания компонента из DLL. Поэтому мы должны изменить CFactory, чтобы она обслуживала как компоненты в DLL, так и компоненты в EXE. Мы также внесем небольшие изменения в CUnknown. Однако код самих компонентов останется тем же самым.

В коде используется символ _OUTPROC_SERVER_, помечающий фрагменты, специфичные для локальных серверов (когда символ определен) или для серверов внутри процесса (когда он не определен). Прежде чем перейти к рассмотрению изменений в CFactory, давайте запустим пример программы.

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

Если Вы решите использовать компонент, реализованный сервером внутри процесса, то все будет работать в точности, как в предыдущей главе. Однако если Вы выберете сервер вне процесса, программа будет работать несколько иначе. Первое, что Вы заметите, — вывод на экран теперь идет только от клиента. Это связано с тем, что компонент в другом процессе использует не то консольное окно, что клиент.

Вместо того, чтобы просто запустить клиент, сначала запустим сервер из командной строки. Дважды щелкните значок SERVER.EXE или воспользуйтесь командой start:

C:\>start server Сервер начнет выполняться, и на экране появится его окно. Теперь запустите клиент и прикажите ему подключиться к локальному серверу. Клиент будет посылать сой вывод в новое консольное окно, а вывод локального сервера пойдет в его собственное окно.

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

DllCanUnloadNow DllRegisterServer DllUnregisterServer DllGetClassObject Теперь нам нужна замена для этих функций. Заменить DllCanUnloadNow легко. EXE, в отличие от DLL, не является пассивным модулем — он управляет своей жизнью сам. EXE может отслеживать счетчик блокировок и, когда тот станет равным 0, выгрузить себя. Следовательно, для EXE нет необходимости реализовывать DllCanUnloadNow. Вычеркиваем ее из списка.

Следующие две функции — DllRegisterServer и DllUnregisterServer — заменить почти так же просто. EXE поддерживают саморегистрацию путем обработки параметров командной строки RegServer и UnRegServer. Все, что должен сделать наш локальный сервер, — это при получении соответствующего параметра командной строки вызвать CFactory::RegisterAll или CFactory::UnregisterAll. Пример кода, выполняющего эти действия, можно найти в файле OUTPROC.CPP. (Попутно замечу, что локальный сервер регистрирует местоположение своего EXE в разделе LocalServer32, а не в разделе InprocServer32. Вы можете заметить соответствующее изменение в файле REGISTRY.CPP.) Таким образом, у нас осталась только DllClassObject, заменить которую несколько труднее, чем остальные функции, экспортируемые DLL.

Запуск фабрик класса Возвращаясь к гл. 7, вспомните, что CoCreateInstance вызывает CoGetClassObject, которая вызывает DllGelClassObject. Последняя возвращает указатель на IClassFactory, который используется для создания компонента. Поскольку EXE не могут экспортировать DllGetClassObject, нужен другой способ передачи CoGetClassObject нашего указателя на IClassFactory.

Решение, предлагаемое СОМ, — поддержка внутренней таблицы зарегистрированных фабрик класса. Когда клиент вызывает CoGetClassObject с соответствующими параметрами, СОМ сначала просматривает свою внутреннюю таблицу фабрик класса, ища заданный клиентом CLSID. Если фабрика класса в таблице отсутствует, то СОМ обращается к Реестру и запускает соответствующий модуль EXE. Задача последнего — как можно скорее зарегистрировать свои фабрики класса, чтобы их могла найти СОМ. Для регистрации фабрики класса EXE использует функцию СОМ CoRegisterClassObject. При запуске EXE обязан зарегистрировать все поддерживаемые им фабрики. Я добавил в CFactory новую стратегическую функцию-член StartFactories, которая вызывает CoRegisterClassObject для каждого компонента в массиве структур CFactoryData. Код этой функции приведен ниже.

BOOL CFactory::StartFactories() { CFactoryData* pStart = &g_FactoryDataArray[0];

const CFactoryData* pEnd = &g_FactoryDataArray[g_cFactoryDataEntries – 1];

for(CFactoryData* pData = pStart;

pData <= pEnd;

pData++) { // Инициализировать указатель и признак фабрики класса pData->m_pIClassFactory = NULL;

pData->m_dwRegister = NULL;

// Создать фабрику класса для компонента IClassFactory* pIFactory = new CFactory(pData);

// Зарегистрировать фабрику класса DWORD dwRegister;

HRESULT hr = ::CoRegisterClassObject( *pData->m_pCLSID, static_cast(pIFactory), CLSCTX_LOCAL_SERVER, REGCLS_MULTIPLEUSE, &dwRegister);

if (FAILED(hr)) { pIFactory->Release();

return FALSE;

} // Запомнить информацию pData->m_pIClassFactory = pIFactory;

pData->m_dwRegister = dwRegister;

} return TRUE;

} Данный код использует две новых переменных-члена, которые я добавил в класс CfactoryData. Переменная m_pIClassFactory содержит указатель на работающую фабрику класса для CLSID, хранящегося в m_pCLSID.

Переменная m_dwRegister содержит магический признак (cookie)1 для данной фабрики.

Как видите, для регистрации фабрики класса нужно лишь ее создать и передать указатель на ее интерфейс функции CoRegisterClassObject. Значение большинства параметров CoRegisterClassObject легко понять из приведенного выше кода. Сначала идет ссылка на CLSID регистрируемого класса, за которой следует указатель на фабрику класса. Магический признак возвращается через последний параметр;

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

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

Четвертый параметр указывает, может ли один экземпляр данного EXE обслуживать более одного экземпляра соответствующего компонента. Проще всего это понять, сравнив сервер EXE с приложением SDI (single document interface — однодокументный интерфейс). Для загрузки нескольких документов необходимо запустить несколько экземпляров такого приложения, тогда как один экземпляр приложения MDI (multiple document interface — многодокументный интерфейс) может открыть несколько документов. Если Ваш сервер EXE похож на приложение SDI, в том смысле, что он может обслуживать только один компонент, следует задать REGCLS_SINGLEUSE и CLSCTX_LOCAL_SERVER.

Если сервер EXE может поддерживать несколько экземпляров компонента, подобно тому, как приложение MDI может открыть несколько документов, используйте REGCLS_MULTI_SEPARATE:

hr = ::CoRegisterClassObject(clsid, pUnknown, CLSCTX_LOCAL_SERVER, REGCLS_MULTI_SEPARATE, &dwRegister);

Кто-то сказал мне, что «cookie» — это не термин информатики, а термин Microsoft. Я не знаю, что это такое, особенно учитывая, что большинство программ просмотра Web оставляют на вашем жестком диске файлы-«cookie». Как бы то ни было, мы в Microsoft используем этот термин для обозначения структуры данных, которая что-либо идентифицирует. Клиент запрашивает у сервера ресурс. Сервер выдает ресурс и возвращает клиенту признак («cookie»), который клиент может в дальнейшем использовать для ссылки на этот ресурс. С точки зрения клиента, «cookie» — это случайное число, смысл которого известен только серверу.

Возникает интересная ситуация. Предположим, что наш EXE-модуль зарегистрировал несколько компонентов.

Пусть, кроме того, этому EXE необходимо использовать один из зарегистрированных им компонентов. Если соответствующая фабрика класса зарегистрирована с помощью приведенного выше оператора, то для обслуживания компонента будет запущен еще один экземпляр EXE. Очевидно, что в большинстве случаев это не столь эффективно, как мы бы хотели. Для регистрации сервера EXE как сервера своих собственных компонентов внутри процесса, объедините, как показано ниже, флаг CLSCTX_LOCAL_SERVER с флагом CLSCTX_INPROG_SERVER:

hr = ::CoRegisterClassObject(clsid, pUnknow, CLSCTX_LOCAL_SERVER | CLSCTX_INPROC_SERVER, REGCLS_MULTI_SEPARATE, &dwRegister);

В результате объединения флажков сервер EXE сможет самостоятельно обслуживать свои компоненты.

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

hr = ::CoRegisterClassObject(clsid, pUnknown, CLS_LOCAL_SERVER, REGCLS_MULTIPLEUSE, &dwRegister);

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

regsvr32 /u server.dll Это гарантирует, что единственным доступным сервером будет локальный. Затем запустите клиент и выберите второй вариант для активации локального сервера. Локальный сервер будет прекрасно работать. Обратите внимание, что в функциях Unit в файлах CMPNT1.CPP и CMPNT2.CPP мы создаем компонент, используя CLSCTX_INPROC_SERVER, — но ведь мы только что удалили информацию сервера внутри процесса из Реестра! Следовательно, наш EXE сам предоставляет себе внутрипроцессные версии этих компонентов.

Теперь заменим REGCLS_MULTIPLEUSE на REGCLS_MULTU_SEPARATE и CFactory::StartFactories. (Строки, которые нужно изменить, помечены в CFACTORY.CPP символами @Multi.) Скомпонуйте клиент и сервер заново, запустите клиент и выберите второй вариант. Вызов создания компонента потерпит неудачу, так как создания внутренних компонентов нет сервера внутри процесса, а REGCLS_MULTI_SEPARATE заставляет СОМ отвергать попытки сервера самостоятельно обслуживать компоненты внутри процесса.

Остановка фабрик класса Когда работа сервера завершается, фабрики класса следует удалить из внутренней таблицы СОМ. Это выполняется при помощи функции библиотеки СОМ CoRevokeClassObject. Метод StopFactories класса CFactory вызывает CoRevokeClassObject для всех поддерживаемых данных EXE фабрик класса:

void CFactory::StopFactories() { CFactoryData* pStart = &g_FactoryDataArray[0];

const CFactoryData* pEnd = &g_FactoryDataArray[g_cFactoryDataEntries – 1];

for (CFactoryData* pData = pStart;

pData <= pEnd;

pData++) { // Прекратить работу фабрики класса с помощью магического признака.

DWORD dwRegister = pData->m_dwRegister;

if (dwRegister != 0) { ::CoRevokeClassObject(dwRegister);

} //Освободить фабрику класса.

IClassFactory* pIFactory = pData->m_pIClassFactory;

if (pIfactory != NULL) { pIFactory->Release();

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

Изменения в LockServer Серверы внутри процесса экспортируют функцию DllCanUnloadNow. Библиотека СОМ вызывает ее, чтобы определить, можно ли выгрузить сервер из памяти. DllCanUnloadNow реализована при помощи статической функции CFactory::CanUnloadNow, которая проверяет значение статической переменной CUnknown::s_ActiveComponents. Всякий раз при создании нового компонента этот счетчик увеличивается.

Однако, как обсуждалось в гл. 7, мы не увеличиваем его значение при создании новой фабрики класса.

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

Теперь должно быть понятно, почему мы не учитывали фабрики класса вместе с активными компонентами.

Первое, что делает локальный сервер, это создает свои фабрики класса;

последнее, что он делает, — удаляет их.

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

Нам необходимо внести некоторые изменения в LockServer, чтобы использовать эту функцию в локальном сервере. Позвольте мне пояснить необходимость изменений. DLL не управляет временем своей жизни. EXE загружает DLL, и EXE выгружает DLL. Однако EXE управляют временем своего существования и могут выгружаться сами. Никто не будет выгружать модуль EXE, он должен делать это сам. Следовательно, нам необходимо изменить LockServer, чтобы завершить работу EXE, когда счетчик блокировок становиться равным нулю. Я добавил к CFactory новую функцию-член CloseExe, которая посылает WM_QUIT в цикл выборки сообщений приложения:

#ifdef _OUTPROC_SERVER_ void CFactory::CloseExe() { if (CanUnloadNow() == S_OK) { ::PostThreadMessage(s_dwThreadID, WM_QUIT, 0,0);

} } #else // CloseExe ничего не делает для сервера внутри процесса.

void CFactory::CloseExe() { /*Пусто*/ } #endif Заметьте, что для сервера внутри процесса эта функция ничего не делает. Чтобы сделать код изумительно эффективным, я просто вызываю CloseExe из LockServer.

HRESULT stdcall CFactory::LockServer(BOOL block) { if (block) { ::InterlockedIncrement(&s_cServerLocks);

} else { ::InterlockedDecrement(&s_cServerLocks);

} // Для сервера вне процесса проверить, можно ли завершить работу программы.

CloseExe();

return S_OK;

} необходимо также вызывать CloseExe из деструкторов компонентов;

это еще одно место, где модуль EXE может определить, нужно ли ему завершить работу. Для этого я изменил деструктор Cunknown:

CUnknown::~CUnknown() { ::InterlockedDecrement(&s_cActiveComponents);

//Если это сервер EXE, завершить работу.

CFactory::CloseExe();

} Цикл сообщений цикл сообщений цикл сообщений… В программах на С и С++ есть стандартная точка входа, которая называется main. С функции main начинается выполнение программы. Программа завершает работу, когда происходит возврат из main. Точно так же в программах для Windows есть функция WinMain. Таким образом, чтобы модуль EXE не прекращал работу, необходим цикл, предотвращающий выход из main или WinMain. Так как наш сервер компонента работает под Windows, я добавил цикл выборки сообщений Windows. Он представляет собой упрощенную версию цикла, используемого всеми программами для Windows.

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

Подсчет пользователей Помните, как мы запускали сервер перед запуском клиента? После завершения работы клиента сервер оставался загруженным. Пользователи сервера — также клиенты, и у них должен быть свой счетчик блокировок. Поэтому, когда пользователь создает компонент, мы увеличиваем CFactory::s_cServerLocks. Таким образом, сервер будет оставаться в памяти, пока с ним работает пользователь.

Как нам определить, что сервер запустил пользователь, а не библиотека СОМ? Когда CoGetClassObject загружает EXE локального сервера, она задает в командной строке аргумент Embedding. EXE проверяет наличие этого аргумента в командной строке. Если Embedding там нет, то сервер увеличивает s_cServerLocks и отображает окно для пользователя.

Когда пользователь завершает работу сервера, с тем по-прежнему могут работать клиенты. Следовательно, когда пользователь завершает программу, сервер должен убрать с экрана пользовательский интерфейс, но не завершаться, пока не закончит обслуживание всех клиентов. Таким образом, сервер не должен посылать себе сообщение WM_QUIT при обработке сообщения WM_DESTROY, если только CanUnloadNow не возвращает S_OK. Вы можете сами посмотреть на соответствующий код в OUTPROC.CPP.

Удаленный сервер Самое замечательное в локальном сервере, который мы реализовали в этой главе, — то, что он является и удаленным сервером. Без каких-либо изменений CLIENT.EXE и SERVER.EXE могут работать друг с другом по сети. Для этого Вам потребуется по крайней мере два компьютера, на которых работает Windows NT 4.0 или Windows 95 с установленной поддержкой DCOM. Естественно, эти компьютеры должны быть соединены между собой сетью.

Чтобы заставить клиента использовать удаленный сервер, воспользуемся программой конфигурации DCOM DCOMCNFG.EXE, которая входит в состав Windows NT. Эта программа позволяет изменять различные параметры приложений, установленных на компьютере, в том числе и то, исполняются ли они локально или удаленно.

В табл. 10-2 представлены пошаговые инструкции для выполнения SERVER.EXE в удаленном режиме.

Таблица 10-2 Запуск SERVER.EXE на удаленной машине Действие Локальный Удаленный компьютер компьютер Скомпонуйте CLIENT, SERVER.EXE и PROXY.DLL с помощью команды nmake-f makefile. Если Вы уже их скомпоновали, делать это заново не нужно. (Я компоновал программы на компьютере с Windows 95 и затем копировал на компьютер с Windows NT.) Скопируйте CLIENT.EXE, SERVER.EXE и PROXY.DLL на удаленный компьютер.

Зарегистрируйте локальный сервер с помощью команды server /RegServer.

Зарегистрируйте заместитель с помощью команды regsvr32 Proxy.dll.

Запустите CLIENT.EXE и выберите вариант локального сервера. Это позволит Вам убедиться, что программы работают на обоих компьютерах.

Запустите DCOMCNFG.EXE. Выберите компонент Inside COM Chapter 10 Example Component 1 и щелкните Properties. Выберите Действие Локальный Удаленный компьютер компьютер вкладкуLocation. Отключите опцию Run Application On This Computer и выберите опцию Run Application On Following Computer. Введите имя удаленного компьютера, на котором будет выполняться SERVER.EXE.

Щелкните вкладку Identity и выберите кнопку-переключатель Interactive User.

В зависимости от Ваших прав доступа может потребоваться изменить установки на вкладке Security.

Запустите SERVER.EXE, чтобы увидеть его вывод на экран.

Запустите CLIENT.EXE и выберите вариант 2, чтобы использовать локальный сервер компонента.

В окне SERVER.EXE должны появиться сообщения.

Сообщения также должны появиться в консольном окне CLIENT.EXE.

Я нахожу поистине восхитительным, что с помощью служебной программы мы можем превратить локальный сервер в удаленный. Остается вопрос — как это работает?

Что делает DCOMCNFG.EXE?

Если после запуска DCOMCNFG.EXE Вы запустите на той же машине REGEDIT.EXE, то сможите увидеть часть этого волшебства в Реестре. Найдите следующий раздел Реестра:

HKEY_CLASSES_ROOT\ CLSID\ {0C092C29-882C-11CA-A6BB-0080C7B2D682} В дополнение к дружественному имени компонента Вы увидите новое значение с именем AppID. CLSID идентифицирует компонент, и соответствующий раздел Реестра содержит информацию о нем. В разделе LocalServer32 указан путь к приложению, в котором реализован компонент, но CLSID никак больше не связан с приложением. Однако DCOM нужно связать с приложением, содержащим компонент, определенную информацию. Для этого используется AppID.

Значением AppID, также как и CLSID, является GUID. Информация об AppID хранится в ветви Реестра AppID;

и здесь аналогично CLSID. Информацию об AppID для SERVER.EXE можно найти в разделе Реестра:

HKEY_CLASSES_ROOT\ AppID\ {0C092C29-882C-11CA-A6BB-0080C7B2D682} В разделе для AppID хранятся как минимум три значения. Значение по умолчанию — дружественное имя. Другие именованные значения — RemoteServerName, задающее имя сервера, на котором находится приложение, и RunAs, сообщающее DCOM, как исполнять приложение. Соответствующая структура Реестра показана на рис. 10-6.

Кроме этого, непосредственно в разделе AppID хранится имя приложения. Вы должны увидеть в Редакторе Реестра такой раздел:

HKEY_CLASSES_ROOT\ AppID\ server.exe В нем только одно именованное значение, которое указывает обратно на AppID.

Но как это работает?

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

Обычно она принимает CLSID и открывает сервер компонента в соответствующем контексте. Если контекстом является CLSCTX_REMOTE_SERVER, CoGetClassObject отыскивает компонент в Реестре и проверяет, задан ли для него AppID. В этом случае функция отыскивает в Реестре значение RemoteServerName. Если имя сервера найдено, то CoGetClassObject пытается запустить сервер удаленно. Именно это и происходило в примере выше.

HKEY_CLASSES_ROOT AppID RemoteServerName {0C092C29-882C-11CF-A6BB-0080C7B2D682} "My Remote Server" RunAs "Interactive User" AppID server.exe {0C092C29-882C-11CF-A6BB-0080C7B2D682} CLSID AppID {0C092C29-882C-11CF-A6BB {0C092C29-882C-11CF-A6BB-0080C7B2D682} 0080C7B2D682} Рис. 10-6 Организация записей Реестра для AppID.

Другая информация DCOM Хотя, перемещаясь по Реестру, можно превратить локальный сервер в удаленный, можно также программно указать, что Вам нужен доступ к удаленному серверу. Для этого следует заменить CoCreateInstance на CoCreateInstanceEx или модифицировать вызов CoGetObject. Ниже приведен пример использования CoCreateInstanceEx для создания удаленного компонента:

// Создать структуру для хранения информации о сервере.

COSERVERINFO ServerInfo;

// Инициализировать структуру нулями.

memset(&ServerInfo, 0, sizeof(ServerInfo));

// Задать имя удаленного сервера.

ServerInfo.pwszName = L”MyRemoveServer”;

// Подготовить структуры MULTI_QI для нужных нам интерфейсов.

MULTI_QI mqi[3];

mqi[0].pIID = IIDX_IX;

// [in] IID требуемого интерфейса mqi[0].pItf = NULL;

// [out] Указатель интерфейса mqi[0].hr = S_OK;

// [out] Результат вызова QI для интерфейса mqi[1].pIID = IIDX_IY;

mqi[1].pItf = NULL;

mqi[1].hr = S_OK;

mqi[2].pIID = IIDX_IZ;

mqi[2].pItf = NULL;

mqi[2].hr = S_OK;

HRESULT hr = CoCreateInstanceEx(CLSID_Component1, NULL, CLSCTX_REMOTE_SERVER, &ServerInfo, 3, // Число интерфейсов &mqi);

Первое бросающееся в глаза отличие CoCreateInstanceEx от CoCreateInstance — то, что первая функция принимаетв качестве параметра структуру COMSERVERINFO, содержащую имя удаленного сервера. Однако самый интересный аспект CoCreateInstanceEx — структура MULTI_QI.

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

В приведенном выше пример мы запрашиваем интерфейсы IX,IY и IZ одновременно. CoCreateInstanceEx возвращает S_OK, если ей удалось получить все интерфейсы, заданные структурами MULTI_QI. Она возвращает E_NOINTERFACE, если не удалось получить ни одно интерфейса. Если же получены некоторые, но не все требуемые интерфейсы, возвращается CO_S_NOTALLINTERFACES.

Код ошибки, связанный с каждым отдельным интерфейсом, записывается в поле hr структуры MULTI_QI.

Указатель на интерфейс возвращается в поле pItf.

Чтобы запросить несколько интерфейсов, CoCreateInstanceEx запрашивает у компонента после его создания интерфейс ImultiQI. Он объявлен так:

interface IMultiQI : IUnknown { virtual HRESULT stdcall QueryMultipleInterfaces (ULONG interfaces, MULTI_QI* pMQUIs);

};

Самое замечательное то, что Вам не нужно реализовывать IMultiQI для своего компонента. Удаленный заместитель компонента предоставляет этот интерфейс автоматически.

CoCreateInstance не работает под Windows Если Вы определите символ препроцессора _WIN32_DCOM или _WIN32_WINNT >= 0x0400, то значения CSLCTX_ALL и CLSCTX_SERVER будут включать в себя CLSCTX_REMOTE_SERVER и не будут работать на системах Windows 95, где не установлена поддержка DCOM. Если Вы разрабатываете программу для Windows 95 или Windows NT 3.51, убедитесь, что эти символы не определены.

Определение наличия DCOM Для того, чтобы определить доступность сервисов DCOM, сначала проверьте, поддерживает ли OLE32.DLL свободные потоки. Если Ваша программа компонуется с OLE32.DLL статически, поступайте так:

if (GetProcAddress(GetModuleHandle(“OLE32”), “CoInitializeEx”) != NULL) { // Свободные потоки поддерживаются.

} Если Вы загружаете OLE32.DLL динамически, используйте следующий фрагмент кода:

hmodOLE32 = LoadLibrary(“OLE32.DLL”);

if (GetProcAddress(hmodOLE32, “CoInitializeEx”) != NULL) { // Свободные потоки поддерживаются.

} Определив, что в системе имеется поддержка свободных потоков, проверьте, включена ли DCOM:

HKEY hKEY;

LONG lResult = RegOpenKeyEx(HKEY_LOCAL_MACHINE, “SOFTWARE\\Microsoft\\Ole”, 0, KEY_ALL_ACCESS, &hKey);

assert(lResult == ERROR_SUCCESS);

char rgch[2];

DWORD cb = sizeof(rgch);

LResult = RegQueryValueEx(hKey, TEXT(“EnableDCOM”), 0, NULL, rgch, &cb);

assert(lResult == ERROR_SUCCESS);

lResult = RegCloseKey(hKey);

assert(lResult == ERROR_SUCCESS);

if (rgch[0] == ‘y’ || rgch[0] == ‘Y’) { // DCOM доступна } Резюме Пересекать границы процессов — увлекательное занятие! Особенно когда у Вас много полезных инструментов (например, компилятор MIDL), которые облегчают эту задачу. Описав свои интерфейсы на IDL, мы можем с помощью MIDL сгенерировать необходимый код заглушки и заместителя для маршалинга интерфейсов через границы процесса. Еще более восхитительна встроенная в DCOM возможность превращать локальные серверы в удаленные простым изменением некоторых записей Реестра.

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

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

Полагаю, что большинству кошек моя версия понравится больше. Один мой друг из Ла Гранде, штат Джорджия, использует другую версию этой фразы: «Есть много способов пахнуть как скунс». Если верить его матери, большинство этих способов ему известно. Все это говорит о том, как много можно придумать способов перефразировать поговорку.

В этой главе Вы увидите, что есть и много способов коммуникации между клиентом и компонентом. В предыдущих главах клиент использовал интерфейс СОМ для работы с компонентом напрямую. В этой главе мы рассмотрим Автоматизацию (в прошлом OLE Автоматизацию) — другой способ управления компонентом. Этот способ использует такие приложения, как Microsoft Word и Microsoft Excel, а также интерпретируемые языки типа Visual Basic и Java.

Автоматизация облегчает интерпретируемым языкам и макроязыкам доступ к компонентам СОМ, а также облегчает написание самих компонентов на этих языках. В Автоматизации делается упор на проверку типов во время выполнения за счет снижения скорости выполнения и проверки типов во время компиляции. Но если Автоматизация проста для программиста на макроязыке, то от разработчика на С++ она требует гораздо больше труда. Во многих случаях Автоматизация заменяет код, генерируемый компилятором, кодом, который написан разработчиком.

Автоматизация — не пристройка к СОМ, а надстройка над нею. Сервер Автоматизации (Automation server) — это компонент СОМ, который реализует интерфейс IDispatch. Контролер Автоматизации (Automation Controller) — это клиент СОМ, взаимодействующий с сервером Автоматизации через интерфейс IDispatch. Контролер Автоматизации не вызывает функции сервера Автоматизации напрямую. Вместо этого он использует методы интерфейса IDispatch для неявного вызова функций сервера Автоматизации.

Интерфейс IDispatch, как и вся Автоматизация, разрабатывался для Visual Basic — чтобы его можно было использовать для автоматизации таких приложений, как Microsoft Word и Microsoft Excel. В конце концов из Visual Basic вырос Visual Basic for Applications — язык для Microsoft Office. Подмножество Visual Basic for Applications — Visual Basic Scripting Edition (VBScript) — можно использовать для автоматизации элементов управления на страницах Web. Версия 5.0 Microsoft Developer Studio использует VBScript в качестве своего макроязыка.

Практически любой сервис, который можно представить через интерфейсы СОМ, можно предоставить и при помощи IDispatch. Из этого следует, что IDispatch и Автоматизация — это не менее (а может быть, и более) широкая тема, чем СОМ. Поскольку эта книга посвящена все-таки СОМ, мы рассмотрим Автоматизацию только частично. Но и этого все еще большая область: IDispatch, disp-интерфейсы, дуальные интерфейсы, библиотеки типа, IDL, VARIANT, BSTR и многое другое. По счастью, именно эти вопросы наиболее важны при программировании Автоматизации на С++.

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

посмотрим, чем работа через IDispatch отличается от работы через интерфейсы СОМ.

Новый способ общения Что делает IDispatch столь замечательным интерфейсом СОМ? Дело в том, что IDispatch предоставляет клиентам и компонентам новый способ общения между собой. Вместо предоставления нескольких собственных интерфейсов, специфичных для его сервисов, компонент может обеспечить доступ к этим сервисам через один стандартный интерфейс, IDispatch.

Прежде чем подробно рассматривать IDispatch, давайте разберемся, как он может поддерживать столь много функций;

для этого мы сравним его со специализированными интерфейсами СОМ (которые он может заменить).

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

Возможно, Вас уже тошнит от этого, но клиент и компонент все же взаимодействуют через интерфейсы.

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

pIX->FxStringOut(msg);

как (*(pIX->pvtbl[IndexOfFxStringOut]))(pIX, msg);

где pvtbl — это указатель на ytbl данного класса, а IndexOfFxStringOut — индекс указателя на функцию FxStringOut в таблице указателей на функции. Все это происходит автоматически — Вы этого не знаете или, в большинстве случаев, Вас это не беспокоит.

Вам придется побеспокоиться об этом при разработке макроязыка для своего приложения. Макроязык будет гораздо мощнее, если сможет использовать компоненты СОМ. Но каким образом макроязык получит смещения функций в vtbl? Я сомневаюсь, что Вы захотите писать синтаксический анализатор С++ для разбора заголовочного файла интерфейса СОМ.

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

IDispatch, или «Я диспетчер, ты диспетчер…»* Говоря попросту, IDipatch принимает имя функции и выполняет ее. Описание IDipatch на IDL, взятое из файла OAIDL.IDL, приведено ниже:

interface IDispatch : IUnknown { HRESULT GetTypeInfoCount([out] UINT * pctinfo);

HRESULT GetTypeInfo([in] UINT iTInfo, [in] LCID lcid, [out] ItypeInfo ** ppTInfo);

HRESULT GetIDsOfNames( [in] REFIID riid, [in, size_is(cNames)] LPOLESTR * rgszNames, [in] UINT cNames, [in] LCID lcid, [out, size_is(cNames)] DISPID * rgDispId);

HRESULT Invoke([in] DISPID dispIdMember, [in] REFIID riid, [in] LCID lcid, [in] WORD wFlags, [in, out] DISPPARAMS * pDispParams, [out] VARIANT * pVarResult, [out] EXCEPINFO * pExcepInfo, [out] UINT * puArgErr);

};

Наиболее интересны в этом интерфейсе функции GetIDsOfNames и Invoke. Первая принимает имя функции и возвращает ее диспетчерский идентификатор, или DISPID. DISPID — это не GUID, а просто длинное целое (LONG), идентифицирующее функцию. DISPID не уникальны (за исключением данной реализации IDipatch). У каждой реализации IDipatch имеется собственный IID (некоторые называют его DIID).

* В оригинале «IDispatch, You Dispatch, We Dispatch». — Прим. перев.

Для вызова функции контроллер автоматизации передает ее DISPID функции-члену Invoke. Последняя использует DISPID как индекс в массиве указателей на функции, что очень похоже на обычные интерфейсы СОМ. Однако сервер Автоматизации не обязан реализовывать Invoke именно так. Простой сервер Автоматизации может использовать оператор switch, который выполняет разный код в зависимости от значения DISPID. Именно так реализовывали оконные процедуры, прежде чем стала популярна MFC.

У оконных процедур и IDispatch::Invoke есть другие общие черты. Как окно ассоциируется с оконной процедурой, так и сервер Автоматизации ассоциируется с функцией IDispatch::Invoke. Microsoft Windows посылает оконной процедуре сообщения;

контроллер автоматизации посылает IDispatch::Invoke разные DISPID.

Поведение оконной процедуры определяется получаемыми сообщениями;

поведение Invoke — получаемыми DISPID.

Способ действий IDispatch::Invoke напоминает и vtbl. Invoke реализует набор функций, доступ к которым осуществляется по индексу. Таблица vtbl — массив указателей на функции, обращение к которым также идет по индексу. Но если vtbl работает автоматически за счет магии компилятора С++, то Invoke работает благодаря тяжкому труду программиста. Однако в С++ vtbl статические, и компилятор работает только во время компиляции. Если программисту С++ необходимо порождать vtbl во время выполнения, он предоставлен самому себе. С другой стороны, легко создать универсальную реализацию Invoke, которая сможет «на лету» адаптироваться для реализации самых разных сервисов.

Disp-интерфейсы У реализации IDispatch::Invoke есть еще одно сходство с vtbl. Обе они определяют интерфейс. Набор функций, реализованных с помощью IDispatch::Invoke, называется диспетчерским интерфейсом (dispatch interface) или, короче, disp-интерфейсом (dispinterface). По определению, интерфейс СОМ — это указатель на массив указателей на функции, первыми тремя из которых являются QueryInterface, AddRef и Release. В соответствии с более общим определением, интерфейс — это набор функций и переменных, посредством которых взаимодействуют две части программы. Реализация IDispatch::Invoke определяет набор функций, посредством которых взаимодействуют сервер и контроллер Автоматизации. Как нетрудно видеть, функции, реализованные Invoke, образуют интерфейс, но не интерфейс СОМ.

На рис. 11-1 диспетчерский интерфейс представлен графически. Слева изображен традиционный интерфейс СОМ — IDispatch реализованный при помощи vtbl. Справа показан disp-интерфейс. Центральную роль в disp интерфейсе играют DISPID, распознаваемые IDispatch::Invoke. На рисунке показана одна из возможных реализаций Invoke и GetIDsOfNames: массив имен функций и массив указателей на функции, индексируемые DISPID. Это только один способ. Для больших disp-интерфейсов GetIDsOfNames работает быстрее, если передаваемое ей имя используется в качестве ключа хеш-таблицы.

Интерфейс IDispatch Disp-интерфейс DISPID Имя IDispatch* pVtbl &QueryInterface pIDispatch 1 "Foo" &AddRef 2 "Bar" функция &Release GetDsOfNames 3 "FooBar" &GetTypeInfoCount Указатель &GetTypeInfo на DISPID функцию &GetDsOfNames 1 &Foo функция &Invoke Invoke 2 &Bar 3 &FooBar Рис. 11-1. Disp-интерфейсы реализуются с помощью IDispatch и не являются интерфейсами СОМ. На этом рисунке представлена только одна из возможных реализаций IDispatch::Invoke.

Конечно, для реализации IDispatch::Invoke можно использовать и интерфейс СОМ (рис. 11-2).

Дуальные интерфейсы На рис. 11-2 представлен не единственный способ реализации disp-интерфейса при помощи интерфейса СОМ.

Другой метод, показанный на рис. 11-3, состоит в том, чтобы интерфейс СОМ, реализующий IDispatch::Invoke, наследовал не IUnknown, а IDispatch. Так реализуют интерфейсы, называемые дуальными интерфейсами (dual interface). Дуальный интерфейс — это disp-интерфейс, все члены которого, доступные через Invoke, доступны и напрямую через vtbl.

Интерфейс IDispatch Disp-интерфейс DISPID Имя IDispatch* pVtbl &QueryInterface pIDispatch 1 "Foo" &AddRef 2 "Bar" функция &Release GetDsOfNames 3 "FooBar" &GetTypeInfoCount &GetTypeInfo Интерфейс FooBar &GetDsOfNames функция pVtbr &Foo &Invoke Invoke &Bar &FooBar Рис. 11-2 Реализация IDispatch::Invoke с помощью интерфейса СОМ.

Интерфейс FooBar наследует Disp-интерфейс интерфейсу IDispatch DISPID Имя IDispatch* pVtbl &QueryInterface pIDispatch 1 "Foo" &AddRef 2 "Bar" функция &Release GetDsOfNames 3 "FooBar" &GetTypeInfoCount &GetTypeInfo &GetDsOfNames функция &Invoke Invoke &Foo &Bar &FooBar Рис. 11-3. Дуальный интерфейс — это интерфейс СОМ, который наследует IDispatch.

Доступ к членам такого интерфейса возможен и через Invoke, и через vtbl.

Дуальные интерфейсы предпочтительны для реализации disp-интерфейсов. Они позволяют программистам на С++ работать через vtbl;

такие вызовы не только легче реализовать на С++, но они и быстрее выполняются.

Макро- и интерпретируемые языки также могут использовать сервисы компонентов, реализующих дуальные интерфейсы, применяя Invoke вместо вызова через vtbl. Программа на Visual Basic может работать с дуальным интерфейсом как с disp-интерфейсом, так и через vtbl. Если Вы объявили тип переменной Visual Basic как Object, то работа идет через disp-интерфейс:

Dim doc As Object Set doc = Application.ActiveDocument doc.Activate Если переменная имеет тип конкретного объекта, то Visual Basic выполняет вызов через vtbl:

Dim doc As Document Set doc = Application.ActiveDocument Doc.Activate Однако если что-то выглядит слишком хорошо, чтобы быть правдой, — вероятно, так оно и есть. Наверное, Вы удивитесь, узнав, что у дуальных интерфейсов есть недостатки. С точки зрения Visual Basic, их и нет. Но с точки зрения контроллера Автоматизации, написанного на С++, их несколько. Основной из них — ограничения на типы параметров.

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

Использование IDispatch Рассмотрим следующую программу на Visual Basic:

Dim Cmpnt As Object Set Cmpnt = CreateObject(“InsideCOM.Chap11.Cmpnt11”) Cmpnt.Fx Эта маленькая программа создает компонент СОМ и вызывает функцию Fx через интерфейс IDispatch, реализованный компонентом. Взглянем теперь на аналогичную программу на С++. Во-первых, необходимо создать компонент по его ProgID. (Эта процедура обсуждалась в гл. 6.) Приведенный ниже код, взятый из файла DCLIENT.CPP примера этой главы (который находится на прилагающемся к книге диске), создает компонент, используя ProgID. (Для ясности я убрал проверки ошибок.) // Инициализировать библиотеку OLE.

HRESULT hr = OleInitialize(NULL);

// Получить CLSID приложения.

wchar_t progid[] = L”InsideCOM.Chap11”;

CLSID clsid;

hr = ::CLSIDFromProgID(progid, &clsid);

// Создать компонент.

IDispatch* pIDispatch = NULL;

hr = ::CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER, IID_IDispatch, (void**)&pIDispatch);

Чтобы не делать лишнего вызова QueryInterface, я запросил у CoCreateInstance указатель на IDispatch. Теперь, имея этот указатель, мы можем получить DISPID функции Fx. Функция IDispatch::GetIDsOfNames принимает имя функции и в виде строки возвращает соответствующий DISPID:

DISPID dispid;

OLECHAR* name = L”Fx”;

pIDispatch->GetIDsOfNames( IID_NULL, // Должно быть IID_NULL &name, // Имя функции 1, // Число имен GetUserDefaultLCID(), // Информация локализации &dispid);

// Диспетчерский идентификатор С точки зрения клиента DISPID — просто средство оптимизации, позволяющее избежать передачи строк. Для сервера же DISPID — идентификатор функции, которую хочет вызвать клиент.

Имея DISPID для Fx, мы можем вызвать эту функцию, передав DISPID IDispatch::Invoke, которая представляет собой сложную функцию. Ниже приведен один из простейших вариантов вызова Invoke. Здесь Fx вызывается без параметров:

// Подготовить аргументы для Fx DISPPARAMS dispparamsNoArgs = { NULL, NULL, 0, // Ноль аргументов 0, // Ноль именованных аргументов };

// Простейший вызов Invoke pIDispatch->Invoke(dispid, // DISPID IID_NULL, // Должно быть IID_NULL GetUserDefultLCID(), // Информация локализации DISPATCH_METHOD, // Метод &dispparamsNoArgs, // Аргументы метода NULL, // Результаты NULL, // Исключение NULL);

// Ошибка в аргументе Контроллер Автоматизации не обязан что-либо знать о сервере Автоматизации. Контроллеру не нужен заголовочный файл с определением функции Fx. Информация об этой функции не зашита в программу. Сравните это с самим интерфейсом IDispatch, который является интерфейсом СОМ. IDispatch определен в OAIDL.IDL. код вызова членов IDispatch генерируется во время компиляции и остается неизменным. Однако вызываемая функция определяется параметрами Invoke. Эти параметры, как и параметры всех функций могут меняться во время выполнения.

Преобразовать приведенный выше фрагмент кода в программу, которая будет вызывать любую функцию без параметров, легко. Просто запросите у пользователя две строки — ProgID и имя функции — и передайте их CLSIDFromProgID и GetIDsOfNames. Код вызова Invoke останется неизменным.

Сила Invoke в том, что она может использоваться в полиморфно. Любой реализующий ее компонент можно вызывать при помощи одного и того же кода. Однако у этого есть своя цена. Одна из задач IDispatch::Invoke — передача параметров вызываемой функции. Число типов параметров, которые Invoke может передавать, ограничено. Более подробно об этом мы поговорим ниже, в разделе, где будет обсуждаться VARIANT. Но прежде чем поговорить о параметрах функций disp-интерфейсов, давайте рассмотрим параметры самой IDispatch::Invoke.

Параметры Invoke Рассмотрим параметры функции Invoke более подробно. Первые три параметра объяснить нетрудно. Первый — это DISPID функции, которую хочет вызвать контроллер. Второй параметр зарезервирован и должен быть равен IID_NULL. Третий параметр содержит информацию локализации. Рассмотрим более детально оставшиеся параметры, начиная с четвертого.

Методы и свойства Все члены интерфейса СОМ — функции. Интерфейсы СОМ, многие классы С++ и даже Win32 API моделируют доступ к переменной с помощью функций «Get» и «Set». Пусть, например, SetVisible делает окно видимым, а GetVisible возвращает текущее состояние видимости окна:

if (pIWindow->GetVisible() == FALSE) { pIWindow->SetVsible(TRUE);

} Но для Visual Basic функций «Get» и «Set» недостаточно. Основная задача Visual Basic — сделать все максимально простым для разработчика. Visual Basic поддерживает понятие свойств (properties). Свойства — это функции «Get/Set», с которыми программист на Visual Basic работает как с переменными. Вместо синтаксиса вызова функции программист использует синтаксис обращения к переменной:

’ Код VB If Window.Visible = False Then Window.Visible = True End If Атрибуты IDL propget и propput указывают, что данная функция СОМ должна рассматриваться как свойство.

Например:

[ object, uuid(D15B6E20-0978-11D0-A6BB-0080C7B2D682), pointer_default(unique), dual ] interface IWindow : IDispatch {...

[propput] HRESULT Visible([in] VARIANT_BOOL bVisible);

Pages:     | 1 |   ...   | 2 | 3 || 5 | 6 |



© 2011 www.dissers.ru - «Бесплатная электронная библиотека»

Материалы этого сайта размещены для ознакомления, все права принадлежат их авторам.
Если Вы не согласны с тем, что Ваш материал размещён на этом сайте, пожалуйста, напишите нам, мы в течении 1-2 рабочих дней удалим его.