Добрынин В.Ю. Технологии компонентного программирования

Подождите немного. Документ загружается.

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

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

GetInfo, семантика которого -

возвращение клиенту строки с полным описанием публикации.

Теперь определим интерфейс

IBook, производный от IPub.

// IBook.h -- интерфейс книги IBook

#ifndef _IBook_

#define _IBook_

#include "IPub.h" // IPub

DECLARE_INTERFACE_(IBook, IPub)

{

STDMETHOD(SetAuthor)(BSTR bstrAuthor) PURE;

};

#endif

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

быть у публикации.

Аналогично определяется интерфейс

IJournal, также производный от IPub, расширяющий последний методом SetNumber -

задание номера журнала.

// IJournal.h -- интерфейс журнала IJournal

#ifndef _IJournal_

#define _IJournal_

#include "IPub.h" // IPub

DECLARE_INTERFACE_(IJournal, IPub)

{

STDMETHOD(SetNumber)(int nNumber) PURE;

};

#endif

В рамках модели COM каждый интерфейс должен иметь уникальный в пространстве и времени идентификатор - IID (Interface

IDentifier). Идентификатор генерируется и присваивается интерфейсу при его создании и более никогда не меняется. Все

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

его идентификатору. Все это позволяет не беспокоиться по поводу присваивания

одного и того же имени различными

разработчиками различным интерфейсам.

Существует спецификация DCE (Distributed Computing Environment - распределенная среда вычислений) от Open Software

Foundation, котрая определяет UUID - Universally Unique IDentifiers (универсально уникальные идентификаторы). Эти

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

COM эти идентификаторы получили название GUID - Globally Unique IDentifiers (глобально уникальные идентификаторы).

Каждый такой идентификатор представляется 128-битным числом

. В связи с тем, что не все языки программирования,

поддерживающие COM, могут оперировать с такими большими числами, для хранения GUID используется следующая структура

typedef struct _GUID

{ unsigned long Data1;

unsigned short Data2;

unsigned short Data3;

unsigned char Data4[8];

} GUID

Эту структуру удобно задавать с помощью следующего макроса

#define DEFINE_GUID(name, \

l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \

EXTERN_C const GUID name \

= { l, w1, w2, { b1, b2, b3, b4, b5, b6, b7, b8 } }

Ниже представлен файл iid.h в котором определены GUID всех трех ранее определенных интерфейсов (позже в этот файл будут

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

guidgen.exe из Visual Studio. Эта утилита позволяет получить определение нового GUID в виде макроса DEFINE_GUID, который

можно скопировать и вставить в файл определений GUID. В закоментированных строках этого файла содержатся значения GUID

в виде, удобном для просмотра человеком. Имя идентификатора интерфейса стандартно формируется следующим образом -

префикс

IID_, за которым следует имя интерфейса. Например, IID_IPub.

// iid.h -- GUID для интерфейсов

// {9A5DE9A0-7225-11d5-98C7-000001223694}

DEFINE_GUID(IID_IPub,

0x9a5de9a0, 0x7225, 0x11d5,

0x98, 0xc7, 0x0, 0x0, 0x1, 0x22, 0x36, 0x94);

// {9A5DE9A1-7225-11d5-98C7-000001223694}

DEFINE_GUID(IID_IBook,

0x9a5de9a1, 0x7225, 0x11d5,

0x98, 0xc7, 0x0, 0x0, 0x1, 0x22, 0x36, 0x94);

// {9A5DE9A2-7225-11d5-98C7-000001223694}

DEFINE_GUID(IID_IJournal,

0x9a5de9a2, 0x7225, 0x11d5,

0x98, 0xc7, 0x0, 0x0, 0x1, 0x22, 0x36, 0x94);

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

Теперь пора перейти к реализации наших интерфейсов. В соответствии с базовой архитектурой COM, интерфейсы реализуются в

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

CoBook и

CoJournal, реализующие соответственно интерфейсы IBook и IJournal. Все названия классов в COM удобно начинать с

префикса

Co, подчеркивая их принадлежность данной модели. Часто классы, определенные в COM, называют коклассами.

Рассмотрим вначале файл

CoBook.h

//////////////////////////////////////////////////

// CoBook.h: заголовочный файл для класс CoBook

//////////////////////////////////////////////////

#ifndef _CoBook_

#define _CoBook_

#include "IBook.h" // определение интерфейса IBook

#include "iid.h" // GUID интерфейса IBook

class CoBook :

public IBook

{

public:

CoBook(); // конструктор

virtual ~CoBook(); // деструктор

// IUnknown

STDMETHODIMP QueryInterface(REFIID riid, void** pIFace);

STDMETHODIMP_(ULONG) AddRef();

STDMETHODIMP_(ULONG) Release();

// IPub

STDMETHODIMP SetTitle(BSTR bstrTitle);

STDMETHODIMP SetYear(int nYear);

STDMETHODIMP GetInfo(BSTR* pbstrInfo);

// IBook

STDMETHODIMP SetAuthor(BSTR bstrAuthor);

private:

ULONG m_refCount; // Счетчик ссылок

BSTR m_bstrTitle; // Название публикации

BSTR m_bstrAuthor; // Автор публикации

int m_nYear; // Год публикации

};

#endif

Здесь определяется класс CoBook, порожденный от интерфейса IBook. Так как интерфейс IBook был сам порожден от интерфейса

IPub, а последний - от стандартного интерфейса IUnknown, то класс CoBook должен реализовать чисто виртуальные методы всех

этих интерфейсов.

Здесь при определении методов используются следующие макросы

#define STDMETHODIMP HRESULT __stdcall

#define STDMETHODIMP_(type) type __stdcall

Теперь надо поговорить об основном стандартном интерфейсе модели COM - IUnknown.

Как уже не раз говорилось, любой интерфейс COM должен порождаться от

IUnknown или от другого интерфейса. Следовательно,

все интерфейсы COM имеют общего предка - интерфейс

IUnknown. Этот интерфейс определяется в <unknwn.h> и его GUID равен

00000000-0000-0000-C000-000000000046.

Интерфейс IUnknown определяет 3 метода, и все эти методы должны быть реализованы в каждом коклассе

z QueryInterface()

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

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

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

знаний о дост

пных инте

рф

ейсах.

Семантика этого метода следующая. Имея указатель некоторого интерфейса pIFace1 некоторого объекта и передавая в

QueryInterface ссылку на идентификатор нового интерфейса IID_IFace2 можно получить указатель на новый интерфейс

pIFace2 , если он реализован в данном объекте. В случае успеха возвращаемое значение S_OK, а в случае неудачи -

E_NOINTERFACE

hr = pIFace1->QueryInterface(IID_IFace2, (void**)&pIFace2);

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

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

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

методы всех интерфейсов (при реализации кокласса на C++). Заметим, что если кокласс

порожден от независимых друг

от друга интерфейсов (т.е. один интерфейс не является потомком другого), то компилятор C++ создает виртуальных

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

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

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

появлений в таблицах виртуальных функций данного класса.

z AddRef()

В COM управление временем жизни объекта выполняется при использовании функций

AddRef() и Release(). Так как

объект может использоваться многими клиентами одновременно, ни один из клиентов не имеет права удалить объект из

памяти. В COM каждый активизированный объект ведет подсчет сделанных на него ссылок. При обнулении этого счетчика

кокласс удаляет себя из памяти. Метод

AddRef() вызывается при появлении новой ссылки на объект и увеличивает

значение счетчика (в нашем случае это

m_refCount) на 1. Возвращает данный метод текущее число ссылок.

z Release()

Этот метод вызывается при освобождении ссылки на объект и уменьшает значение счетчика на 1. Он же удаляет кокласс из

памяти при обнулении счетчика ссылок. Метод возвращает текущее число ссылок.

Теперь реализация класса

CoBook

//////////////////////////////////////////////////

// CoBook.cpp: реализация класса CoBook.

//////////////////////////////////////////////////

#include <stdio.h>

#include "CoBook.h"

extern ULONG g_objCount; // Счетчик числа объектов

//////////////////////////////////////////////////

// Конструктор и деструктор

//////////////////////////////////////////////////

CoBook::CoBook()

{

m_refCount = 0;

++g_objCount;

m_bstrTitle = SysAllocString(L"");

m_bstrAuthor = SysAllocString(L"");

}

CoBook::~CoBook()

{

--g_objCount;

if(m_bstrTitle)

SysFreeString(m_bstrTitle);

if(m_bstrAuthor)

SysFreeString(m_bstrAuthor);

}

// IUnknown

STDMETHODIMP_(ULONG) CoBook::AddRef()

{

return ++m_refCount;

}

STDMETHODIMP_(ULONG) CoBook::Release()

{

if (--m_refCount == 0)

{

delete this;

return 0;

}

else

return m_refCount;

}

STDMETHODIMP CoBook::QueryInterface(REFIID riid, void** pIFace)

{

if (riid == IID_IUnknown)

{

*pIFace = (IUnknown*)this;

}

else if (riid == IID_IPub)

{

*pIFace = (IPub*)this;

}

else if (riid == IID_IBook)

{

*pIFace = (IBook*)this;

}

else

{

*pIFace = NULL;

return E_NOINTERFACE;

}

((IUnknown*)(*pIFace))->AddRef();

return S_OK;

}

// IPub & IBook

STDMETHODIMP CoBook::SetTitle (BSTR bstrTitle)

{

SysReAllocString(&m_bstrTitle, bstrTitle);

return S_OK;

}

STDMETHODIMP CoBook::SetYear(int nYear)

{

m_nYear = nYear;

return S_OK;

}

STDMETHODIMP CoBook::SetAuthor(BSTR bstrAuthor)

{

SysReAllocString(&m_bstrAuthor, bstrAuthor);

return S_OK;

}

STDMETHODIMP CoBook::GetInfo(BSTR *pbstrInfo)

{

char* pszTitle = NULL;

char* pszAuthor = NULL;

char* pszText = NULL;

int nAuthorLength, nTitleLength;

nAuthorLength = SysStringLen(m_bstrAuthor);

nTitleLength = SysStringLen(m_bstrTitle);

pszAuthor = (char*)malloc(2*nAuthorLength);

pszTitle = (char*)malloc(2*nTitleLength);

pszText = (char*)malloc(2*nAuthorLength +

2*nTitleLength + 50);

wcstombs(pszTitle, m_bstrTitle, 2*nTitleLength);

wcstombs(pszAuthor, m_bstrAuthor, 2*nAuthorLength);

sprintf(pszText,

"Book\n\nAuthor : %s\nTitle : %s\nYear : %d",

pszAuthor, pszTitle, m_nYear);

*pbstrInfo = SysAllocStringLen(NULL, 2*strlen(pszText));

mbstowcs(*pbstrInfo, pszText, 2*strlen(pszText));

free(pszAuthor);

free(pszTitle);

free(pszText);

return S_OK;

}

В конструкторе CoBook() задается начальное нулевое значение для счетчика числа ссылок на данный объект и увеличивается на 1

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

памяти сервера, возможно содержащего не только класс CoBook, но и какие-то другие классы. Кроме того, члены класса

m_bstrTitle и m_bstrAuthor получают в качестве значения пустую строку. Префикс L перед строкой константой говорит о том,

что в этой строке на один символ отводится два байта. Для ее преобразования к типу BSTR и размещения в памяти используется

функция SysAllocString().

В деструкторе

CoBook() при уничтожении объекта на 1 уменьшается счетчик объектов и освобождается память, выделенная

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

SysFreeString().

Реализация методов

AddRef() и Release() тривиальна и полность соответствует предписанной семантике этих методов.

Метод

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

Заметим, что среди этих интерфейсов не только IBook, но и все интерфейсы, от которых прямо или косвенно IBook порожден -

IPub и IUnknown. Если запрашиваемый интерфейс не найден, возвращается E_NOINTERFACE. В противном случае вызывается

метод

AddRef() интерфейса IUnknown, увеличивающий счетчик ссылок на данный объект. Вызвать функцию Release() при

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

QueryInterface() обязан уже клиент.

Методы

SetTitle(), SetYear() и SetAuthor() позволяют задать соответственно название, год издания и имя автора книги -

нового объекта

CoBook. При передачи в качестве входного аргумента BSTR-строки происходит переразмещение в памяти

соответствующей

BSTR-строки - члена класса. Для этого используется функция SysReAllocString().

Метод

GetInfo() возвращает информацию о книге в строке типа BSTR. Вся информация о книге хранится в экземпляре класса

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

ANSI-строки. Для выполнения преобразования BSTR-строки в ANSI-строку применяется функция wcstombs(). Первый параметр

задает буфер для

ANSI-строки, второй - BSTR-строку, третий - размер буфера. Функция SysStringLen() позволяет определить

длину

BSTR-строки в символах. Размер буфера для соответствующей ANSI-строки выбирается в два раза превосходящим длину

BSTR-строки, т.к. некоторые Unicode-символы представляются двумя ANSI-символами. Далее в буфер pszText помещается вся

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

BSTR-строку *pbstrInfo и вызывается функция преобразования

ANSI-строки pszText в BSTR-строку *pbstrInfo - mbstowcs().

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

SysAllocStringLen(). Первый параметр задает BSTR-

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

параметра NULL мы получаем неинициализированную BSTR-строку длины, заданной вторым параметром.

Последнее действие - освобождение памяти, выделенной под буферы.

Далее определяется и реализуется класс

CoJournal, порожденный от интерфейса IJournal. Так как интерфейс IJournal был сам

порожден от интерфейса

IPub, а последний - от стандартного интерфейса IUnknown, то класс CoJournal должен реализовать

чисто виртуальные методы всех этих интерфейсов. Данный класс мало отличается от класса

CoBook, в связи с чем комментарии

минимальны.

//////////////////////////////////////////////////

// CoJournal.h: заголовочный файл для класс CoJournal.

//////////////////////////////////////////////////

#ifndef _CoJournal_

#define _CoJournal_

#include "IJournal.h"

#include "iid.h"

class CoJournal :

public IJournal

{

public:

CoJournal();

virtual ~CoJournal();

// IUnknown

STDMETHODIMP QueryInterface(REFIID riid, void** pIFace);

STDMETHODIMP_(ULONG) AddRef();

STDMETHODIMP_(ULONG) Release();

// IPub

STDMETHOD(SetTitle)(BSTR bstrTitle);

STDMETHOD(SetYear)(int nYear);

STDMETHOD(GetInfo)(BSTR* pbstrInfo);

// IJournal

STDMETHOD(SetNumber)(int nNumber);

private:

ULONG m_refCount; // Счетчик ссылок

BSTR m_bstrTitle; // Название публикации

int m_nYear; // Год публикации

int m_nNumber; // Номер журнала

};

#endif

И теперь реализация класса CoJournal

//////////////////////////////////////////////////

// CoJournal.cpp: реализация класса CoJournal.

//////////////////////////////////////////////////

#include <stdio.h>

#include "CoJournal.h"

#include <stdio.h>

#include "CoJournal.h"

extern ULONG g_objCount; // Счетчик числа объектов

//////////////////////////////////////////////////

// Конструктор и деструктор

//////////////////////////////////////////////////

CoJournal::CoJournal()

{

m_refCount = 0;

++g_objCount;

m_bstrTitle = SysAllocString(L"");

}

CoJournal::~CoJournal()

{

--g_objCount;

if(m_bstrTitle)

SysFreeString(m_bstrTitle);

}

// IUnknown

STDMETHODIMP_(ULONG) CoJournal::AddRef()

{

return ++m_refCount;

}

STDMETHODIMP_(ULONG) CoJournal::Release()

{

if (--m_refCount == 0)

{

delete this;

return 0;

}

else

return m_refCount;

}

STDMETHODIMP CoJournal::QueryInterface(REFIID riid, void** pIFace)

{

if (riid == IID_IUnknown)

{

*pIFace = (IUnknown*)this;

}

else if (riid == IID_IJournal)

{

*pIFace = (IJournal*)this;

}

else

{

*pIFace = NULL;

return E_NOINTERFACE;

}

((IUnknown*)(*pIFace))->AddRef();

return S_OK;

}

// IPub & IJournal

STDMETHODIMP CoJournal::SetTitle (BSTR bstrTitle)

{

SysReAllocString(&m_bstrTitle, bstrTitle);

return S_OK;

}

STDMETHODIMP CoJournal::SetYear(int nYear)

{

m_nYear = nYear;

return S_OK;

}

STDMETHODIMP CoJournal::SetNumber(int nNumber)

{

m_nNumber = nNumber;

return S_OK;

}

STDMETHODIMP CoJournal::GetInfo(BSTR *pbstrInfo)

{

char* pszTitle = NULL;

char* pszText = NULL;

int nTitleLength;

nTitleLength = SysStringLen(m_bstrTitle);

pszTitle = (char*)malloc(2*nTitleLength);

pszText = (char*)malloc(2*nTitleLength + 50);

wcstombs(pszTitle, m_bstrTitle, 2*nTitleLength);

sprintf(pszText, "Journal\n\nTitle : %s\nYear : %d\nNumber :

%d\n", pszTitle, m_nYear, m_nNumber);

*pbstrInfo = SysAllocStringLen(NULL, 2*strlen(pszText));

mbstowcs(*pbstrInfo, pszText, 2*strlen(pszText));

free(pszTitle);

free(pszText);

return S_OK;

}

Теперь, когда коклассы CoBook и CoJournal реализованы, им следует присвовить GUID и добавить соответствующую

информацию в файл

iid.h. Вот последняя версия этого файла

// GUID для всех интерфейсов и классов

// {9A5DE9A0-7225-11d5-98C7-000001223694}

DEFINE_GUID(IID_IPub,

0x9a5de9a0, 0x7225, 0x11d5,

0x98, 0xc7, 0x0, 0x0, 0x1, 0x22, 0x36, 0x94);

// {9A5DE9A1-7225-11d5-98C7-000001223694}

DEFINE_GUID(IID_IBook,

0x9a5de9a1, 0x7225, 0x11d5,

0x98, 0xc7, 0x0, 0x0, 0x1, 0x22, 0x36, 0x94);

// {9A5DE9A2-7225-11d5-98C7-000001223694}

DEFINE_GUID(IID_IJournal,

0x9a5de9a2, 0x7225, 0x11d5,

0x98, 0xc7, 0x0, 0x0, 0x1, 0x22, 0x36, 0x94);

// {49F00760-7238-11d5-98C7-000001223694}

DEFINE_GUID(CLSID_CoBook,

0x49f00760, 0x7238, 0x11d5,

0x98, 0xc7, 0x0, 0x0, 0x1, 0x22, 0x36, 0x94);

// {49F00761-7238-11d5-98C7-000001223694}

DEFINE_GUID(CLSID_CoJournal,

0x49f00761, 0x7238, 0x11d5,

0x98, 0xc7, 0x0, 0x0, 0x1, 0x22, 0x36, 0x94);

Обратите внимание, что имя идентификатора кокласса стандартно формируется следующим образом - префикс CLSID_, за

которым следует имя кокласса. Например,

CLSID_CoBook.

Фабрики классов

Теперь возникает важный вопрос - как клиент может создавать COM объекты CoBook и CoJournal?

Два важных принципа COM:

z Независимость от языка

В соответствии с идеологией модели COM, классы COM (коклассы) могут реализовываться на различных языках и должны

храниться в бинарном виде (dll или exe файл). Клиент может быть реализован на любом из поддерживающих модель COM

языке и, следовательно, должен иметь возможность создавать (активизировать) COM объект не используя каких-либо

специфических для данного языка методов, а

с помощью специального стандартного интерфейса.

z Прозрачность местоположения сервера

Имеется три места, где может размещаться COM сервер:

{ В процессе клиента

Этот способ обеспечивает самую быструю связь клиента и сервера (который реализуется в виде dll). Но есть и

проблемы. Например, при ошибке в сервере ``вылетает'' весь процесс (т.е. и клиент).

{ Вне процесса клиента, но на одной с ним машине

Это так назывемая локальная связь (обычно используется exe-сервер). Она обеспечивает надежность (при ошибках в

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

процессов. Это COM берет на себя, обеспечивая кодирование, передачу и декодирование данных. При этом

создаются

прокси объект в процессе клиента и заглушка в процессе сервера. Прокси имитирует для клиента сервер, а заглужка

имитирует для сервера клиента. В связи с этим код клиента не зависит от того, где располагается сервер. Все

преобразование данных и их пересылка осуществляется парой прокси-заглушка. Коммутация прокси и заглушки

основана

на протоколе упрощенного удаленного вызова процедур (LRPC - Lightweight Remote Procedure Call).

{ На удаленной машине

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

вместо LRPC используется RPC - протокол удаленного вызова процедур.

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

изменении местоположения сервера. Более того, сервер может располагаться в нескольких местах, и

по просьбе клиента

система (менеджер управления сервисом), может устанавливать связь клиента с ближайшей к нему копией сервера.

Итак, нужен стандартный интерфейс для активации COM объекта. Такой интерфейс в COM имеется и называется

IClassFactory

(определен в <unknwn.h>). Для каждого кокласса, ``живущего'' в некотором сервере, в этом же сервере должен ``жить'' класс,

реализующий так называемую фабрику класса (или объект класса). Именно фабрика класса предоставляет клиенту интерфейс

IClassFactory и более никаких других интерфейсов (кроме, естественно, IUnknown, от которого IClassFactory порожден как и

все остальные COM интерфейсы).

Интерфейс

IClassFactory имеет два метода:

z CreateInstance

С помощью этого метода клиент, имеющий указатель на фабрику некоторого класса, может создать любое число

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

z LockServer

Для активации какого-либо COM объекта необходимо размещение сервера, в котором ``живет'' данный объект, в

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

больше нет. Если нет активных объектов, ``живущих'' в сервере, то сервер также может быть удален из памяти. Но клиент

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

этого он и может вызвать метод

LockServer.

Далее для определенности будем рассматривать построение dll-сервера (сервера в процессе клиента). Естественно, этот выбор

никак не скажется на коде клиента. Построение локального сервера (сервер вне процесса клиента, но на этой же машине) будет

рассмотрено позже.

Следующий код содержит определение фабрики класса для кокласса

CoBook.

//////////////////////////////////////////////////

// CoBookFactory.h: заголовочный файл для класса CoBookFactory --

// фабрика класса для класса CoBook

//////////////////////////////////////////////////

#ifndef _CoBookFactory_

#define _CoBookFactory_

#include "CoBook.h"

class CoBookFactory : public IClassFactory

{

public:

// Конструктор и деструктор

CoBookFactory();

virtual ~CoBookFactory();

//IUnknown

STDMETHODIMP QueryInterface(REFIID riid, void** pIFace);

STDMETHODIMP_(ULONG)AddRef();

STDMETHODIMP_(ULONG)Release();

//IClassFactory

STDMETHODIMP LockServer(BOOL fLock);

STDMETHODIMP CreateInstance(LPUNKNOWN pUnkOuter,

REFIID riid, void** ppv);

private:

ULONG m_refCount; // Счетчик числа сылок на объект

};

#endif

Здесь стандартным образом объявлены конструктор, деструктор, три метода интерфейса IUnknown и два метода интерфейса

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

методов

LockServer и CreateInstance.

Параметр

fLock принимает значение TRUE - заблокировать сервер, или FALSE - разблокировать сервер. Сервер ведет подсчет всех

блокировок, установленных всеми его клиентами, и разрешает выгрузить себя из памяти, если только не осталось активных

объектов и общий счет блокировок в памяти равен нулю.

Первый параметр метода

CreateInstance используется только при агрегации, которая обсуждалась ранее . Именно, если класс

CoBook проектируется с возможностью его агрегации в другой COM класс (класс CoBook готов предоставить возможность

другому классу выдавать интерфейсы класса

CoBook за свои), то через параметр pUnkOuter (тип которого определяется в

<unknwn.h> как typedef IUnknown __RPC_FAR * LPUNKNOWN) он получает указатель интерфейса IUnknown того объекта, который

его собрался агрегировать. Если

CoBook не проектировался с возможностью агрегации (так и есть в нашем случае), то он ожидает

получение в этом параметре значения

NULL, в противном случае тут будет выдана ошибка CLASS_E_NOAGGREGATION.

Второй параметр метода

CreateInstance задает ссылку на идентификатор желаемого интерфейса, а третий возвращает

запрошенный интерфейс (если он имеется).

Реализация фабрики класса

CoBookFactory для класса CoBook представлена ниже.

//////////////////////////////////////////////////

// CoBookFactory.cpp: реализация класса CoBookFactory --

// фабрики класса для класса CoBook.

//////////////////////////////////////////////////

#include "CoBookFactory.h"

extern ULONG g_lockCount; // Счетчик блокировок сервера в памяти

extern ULONG g_objCount; // Счетчик активных объектов

//////////////////////////////////////////////////

// Конструктор и деструктор

//////////////////////////////////////////////////

CoBookFactory::CoBookFactory()

{

m_refCount = 0;

g_objCount++;

}

CoBookFactory::~CoBookFactory()

{

g_objCount--;

}

//IUnknown

STDMETHODIMP_(ULONG) CoBookFactory::AddRef()

{

return ++m_refCount;

}

STDMETHODIMP_(ULONG) CoBookFactory::Release()

{

if (--m_refCount == 0)

{

delete this;

return 0;

}

else

return m_refCount;

}

STDMETHODIMP CoBookFactory::QueryInterface(REFIID riid, void** ppv)

{

if(riid == IID_IUnknown)

{

*ppv = (IUnknown*)this;

}

else if(riid == IID_IClassFactory)

{

*ppv = (IClassFactory*)this;

}

else

{

*ppv = NULL;

return E_NOINTERFACE;

}

((IUnknown*)(*ppv))->AddRef();

return S_OK;

}

//IClassFactory

STDMETHODIMP CoBookFactory::CreateInstance(

LPUNKNOWN pUnkOuter, REFIID riid, void** ppv)

{

if(pUnkOuter != NULL)

{

return CLASS_E_NOAGGREGATION;

}

CoBook* pBookObj = NULL;

HRESULT hr;

pBookObj = new CoBook;

hr = pBookObj->QueryInterface(riid, ppv);

if (FAILED(hr))

delete pBookObj;

return hr;

}

STDMETHODIMP CoBookFactory::LockServer(BOOL fLock)

{

if (fLock)

++g_lockCount;

else

--g_lockCount;

return S_OK;

}

В конструкторе обнуляется счетчик ссылок на фабрику класса - член класса m_refCount (как всегда при создании любого объекта

COM) и увеличивается на единицу глобальный счетчик числа активных объектов данного сервера (

g_objCount).

В деструкторе на единицу уменьшается глобальный счетчик активных объектов данного сервера.

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

IUnknown стандартная и уже обсуждалась ранее.

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

IClassFactory и начнем с метода CreateInstance.

Во-первых, не предполагается агрегация класса

CoBook. В связи с этим выдается ошибка CLASS_E_NOAGGREGATION, если первый

параметр не равен

NULL.

В следующих строках кода и проявляется связь данной фабрики класса именно с классом

CoBook. Создается экземпляр класса

CoBook и запрашивается указатель на некоторый интерфейс этого класса:

CoBook* pBookObj = NULL;

HRESULT hr;

pBookObj = new CoBook;

hr = pBookObj->QueryInterface(riid, ppv);

При неудаче получения интерфейса, созданный объект уничтожается.

В методе

LockServer глобальный счетчик блокировок сервера в памяти увеличивается или уменьшается на единицу в

зависимости от значения параметра

fLock.

Совершенно аналогично определяется и реализуется фабрика класса

CoJournalFactory для кокласса CoJournal.

//////////////////////////////////////////////////

// CoJournalFactory.h: заголовочный файл для класса

// CoJournalFactory -- фабрики класса для класса CoJournal

//////////////////////////////////////////////////

#ifndef _CoJournalFactory_

#define _CoJournalFactory_

#include "CoJournal.h"

class CoJournalFactory : public IClassFactory

{

public:

CoJournalFactory();

virtual ~CoJournalFactory();

//IUnknown

STDMETHODIMP QueryInterface(REFIID riid, void** pIFace);

STDMETHODIMP_(ULONG)AddRef();

STDMETHODIMP_(ULONG)Release();

//IClassFactory

STDMETHODIMP LockServer(BOOL fLock);

STDMETHODIMP CreateInstance(LPUNKNOWN pUnkOuter,

REFIID riid, void** ppv);

private:

ULONG m_refCount;

};

#endif

И теперь реализация фабрики класса CoJournalFactory для класса CoJournal.

//////////////////////////////////////////////////

// CoJournalFactory.cpp: реализация фабрики класса CoJournalFactory

// для кокласса CoJournal

//////////////////////////////////////////////////

#include "CoJournalFactory.h"

extern ULONG g_lockCount;

extern ULONG g_objCount;

//////////////////////////////////////////////////

// Конструктор и деструктор

//////////////////////////////////////////////////