Программирование -> C/C++ -> Сущность технологии COM

Двоичная композиция

Композиция и отделяемые интерфейсы - это две технологии на уровне исходного кода, предназначенные для реализации объектов СОМ на C++. Обе эти технологии требуют, чтобы разработчик объекта имел определения для каждого класса композита или отделяемого интерфейса в исходном коде C++, для возможности обработать подобъект, прежде чем возвратить его посредством QueryInterface. Для ряда ситуаций это очень разумно. В некоторых случаях, однако, было бы удобнее упаковать многократно используемую реализацию одного или большего числа интерфейсов в двоичный компонент, который мог бы обрабатываться через границы DLL, не нуждаясь в исходном коде подкомпонента. Это позволило бы более широкой аудитории повторно использовать подкомпонент, избегая слишком тесной связи с ним, как в случае повторного использования на уровне исходного кода (этот случай описан в главе 1). Однако если компонент повторного использования представляет собой двоичный композит или отделяемый интерфейс, то он должен участвовать в общей идентификации объекта.

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

class Car : public ICar { 
    LONG m_cRef;
    Car(void) : m_cRef(0) {}
    STDMETHODIMP QueryInterface(REFIID, void **);
    STDMETHODIMP_(ULONG) AddRef(void);
    STDMETHODIMP_(ULONG) Release(void);
    STDMETHODIMP GetMaxSpeed(long *pn);
    STDMETHODIMP Brake(void);
};

STDMETHODIMP Car::QueryInterface(REFIID riid, void **ppv) 
{
    if (riid == IID_IUnknown)
        *ppv = static_cast<IUnknown*>(this);
    else if (riid == IID_IVehicle)
        *ppv = static_cast<IVehicle*>(this);
    else if (riid == IID_ICar)
        *ppv = static_cast<ICar*>(this);
    else
        return (*ppv = 0), E_NOINTERFACE;
    ((IUnknown*)*ppv)->AddRef();
    return S_OK;
}

// car class object's IClassFactory::CreateInstance
// интерфейс IClassFactory::CreateInstance
// объекта класса car
STDMETHODIMP CarClass::CreateInstance(IUnknown *pUnkOuter, REFIID riid, void **ppv)
{
    Car *pCar = new Car;
    if (*pCar) 
        return (*ppv = 0), E_OUTOFMEMORY;
    pCar->AddRef();
    HRESULT hr = pCar->QueryInterface(riid, ppv);
    pCar->Release();
    return hr;
}

Этот класс просто использует фактические реализации QueryInterface, AddRef и Release.

Рассмотрим второй класс C++, который пытается использовать реализацию Car как двоичный композит:

class CarBoat : public IBoat {
    LONG m_cRef;
    Unknown *m_pUnkCar;
    CarBoat(void);
    virtual ~CarBoat(void);
    STDMETHODIMP QueryInterface(REFIID, void **);
    STDMETHODIMP_(ULONG) AddRef(void);
    STDMETHODIMP_(ULONG) Release(void);
    STDMETHODIMP GetMaxSpeed(long *pn);
    STDMETHODIMP Sink(void);
};

Для эмуляции композиции разработчику пришлось бы создать подобъект Car, а деструктору - освободить указатель на подобъект:

CarBoat::CarBoat (void) : m_cRef(0) 
{
    HRESULT hr = CoCreateInstance(CLSID_Car, 0, CLSCTX_ALL, 
                                  IID_IUnknown, (void**)&m_pUnkCar);
    assert(SUCCEEDED(hr));
}

CarBoat::~CarBoat(void) 
{
    if (m_pUnkCar) 
        m_pUnkCar->Release();
}

Интересная проблема возникает в реализации QueryInterface:

STDMETHODIMP CarBoat::QueryInterface(REFIID riid, void **ppv) 
{
    if (riid == IID_IUnknown)
        *ppv = static_cast<IUnknown*>(this);
    else if (riid == IID_IVehicle)
        *ppv = static_cast<IVehicle*>(this);
    else if (riid == IID_IBoat)
        *ppv = static_cast<IBoat*>(this);
    else if (riid == IID_ICar)
      // forward request...
      // переадресовываем запрос...
        return m_pUnkCar->QueryInterface(riid, ppv);
    else
        return (*ppv = 0), E_NOINTERFACE;
    ((IUnknown*)*ppv)->AddRef();
    return S_OK;
}

Поскольку объект Car не имеет понятия о том, что он является частью идентификационной единицы (identity) другого объекта, то он будет причиной неуспеха любых запросов QueryInterface для IBoat. Это означает, что

QI(IBoat)->ICar 

пройдет успешно, а запрос

QI(QI(IBoat)->ICar)->IBoat

потерпит неудачу, так как полученная QueryInterface будет несимметричной. Вдобавок запросы QueryInterface о IUnknown через интерфейсные указатели ICar и IBoat вернут различные значения, а это означает, что будет идентифицировано два различных объекта. Из подобных нарушений протокола IUnknown следует, что объекты CarBoat попросту не являются действительными объектами СОМ.

Идея составления объекта из двоичных композитов звучит красиво. Действительно, Спецификация СОМ четко и подробно указывает, как реализовать эту идею в стандартной и предсказуемой манере. Технология выставления клиенту двоичного подкомпонента непосредственно через QueryInterface называется СОМ-агрегированием. СОМ-агрегирование является лишь набором правил, определяющих отношения между внешним объектом (агрегирующим) и внутренним (агрегируемым). СОМ-агрегирование - это просто набор правил IUnknown, позволяющих более чем одному двоичному компоненту фигурировать в качестве идентификационной единицы (identity) СОМ.

Агрегирование СОМ несомненно является главной движущей силой для повторного использования в СОМ. Намного проще приписывать объекту значения и использовать его методы в реализации методов других объектов. Только в редких случаях кто-то захочет выставлять интерфейсы другого объекта непосредственно клиенту как часть той же самой идентификационной единицы. Рассмотрим следующий сценарий:

class Handlebar : public IHandlebar { ... };
class Wheel : public IWheel {};

class Bicycle : public IBicycle { 
    IHandlebar * m_pHandlebar;
    IWheel *m_pFrontWheel;
    IWheel *m_pBackWheel;
}

Было бы опрометчиво для класса Вicycle объявлять интерфейсы IHandlebar (велосипедный руль) или IWheel (колесо) в собственном методе QueryInterface. QueryInterface зарезервирован для выражения отношений "является" (is-a), а велосипед (bicycle) очевидно не является колесом (wheel) или рулем (handlebar). Если разработчик Bicycle хотел бы обеспечить прямой доступ к этим сторонам объекта, то интерфейс IBicycle должен был бы иметь для этой цели аксессоры определенных свойств:

[object, uuid(753A8A60-A7FF-11d0-8C30-0080C73925BA)]
interface IBicycle : IVehicle {
    HRESULT GetHandlebar([out,retval] IHandlebar **pph);
    HRESULT GetWheels([out] IWheel **ppwFront, [out] IWheel **ppwBack);
}

Реализация Bicycle могла бы тогда просто возвращать указатели на свои подобъекты:

STDMETHODIMP Bicycle::GetHandlebar(IHandlebar **pph)
{
    if (*pph = m_pHandlebar)
        (*pph)->AddRef();
    return S_OK;
}

STDMETHODIMP Bicycle::GetWheels(IWheel **ppwFront, IWheel **ppwBack)
{
    if (*ppwFront = m_pFrontWheel) 
        (*ppwFront)->AddRef();
    if (*ppwBack = m_pBackWheel) 
        (*ppwBack)->AddRef();
    return S_OK;
}

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

Несмотря на этот пример, все же остаются сценарии, где желательно обеспечить реализацию интерфейса, которая могла бы быть внедрена в идентификационную единицу другого объекта. Чтобы осуществить это, в СОМ-агрегировании требуется, чтобы внутренний объект (агрегируемый) уведомлялся во время его создания, что он создается как часть идентификационной единицы другого объекта. Это означает, что создающая функция (creation function), обычно используемая для создания объекта, требует один дополнительный параметр: указатель IUnknown на идентификационную единицу, которой агрегирующий объект должен передать функции в ее методы QueryInterface, AddRef и Release. Покажем определение метода CreateInstance интерфейса IClassFactory:

HRESULT CreateInstance([in] Unknown *pUnkOuter,
                       [in] REFIID riid, [out, iid_is(riid)] void **ppv);

Этот метод (и соответствующие API-функции CoCreateInstanceEx и CoCreateInstance) перегружен с целью поддержки создания автономных (stand-alone) объектов и агрегатов. Если вызывающий объект передает нулевой указатель и качестве первого параметра CreateInstance (pUnkOuter), то результирующий объект будет автономной идентификационной единицей самого себя. Если же вызывающий объект передает в качестве первого параметра ненулевой указатель, то результирующий объект будет агрегатом с идентификационной единицей, ссылка на которую содержится в pUnkOuter. В случае агрегации агрегат должен переадресовывать все запросы QueryInterface, AddRef и Release непосредственно и безусловно на pUnkOuter. Это необходимо для обеспечения идентификации объекта.

Имея прототип функции, приведенный выше, класс CarBoat после небольшой модификации будет удовлетворять правилам агрегации:

CarBoat::CarBoat(void) : m_cRef(0) {
      // need to pass identity of self to Create routine
      // to notify car object it 1s an aggregate
      // нужно передать свою идентификацию подпрограмме
      // Create для уведомления объекта car, что он - агрегат
    HRESULT hr = CoCreateInstance(CLSID_Car, this,
                         CLSCTX_ALL, IID_IUnknown, (void**)&m_pUnkCar);
    assert(SUCCEEDED(hr));
}

Реализация CarBoat QueryInterface просто переадресовывает запрос ICar внутреннему агрегату:

STDMETHODIMP CarBoat::QueryInterface(REFIID riid, void **ppv)
{ 
    if (riid == IID_IUnknown) 
        *ppv = static_cast<IUnknown*>(this);
    else if (riid == IID_ICar)
        // forward request...
        // переадресовываем запрос...
        return m_pUnkCar->QueryInterface(riid, ppv);
    else if (riid == IID_IBoat)
    :    :    :

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

В предыдущем сценарии метод CreateInstance класса Car возвращает внешнему объекту указатель интерфейса, наследующего IUnknown. Если бы этот интерфейсный указатель должен был просто делегировать вызовы функций интерфейсу IUnknown внешнего объекта, то невозможно было бы: 1) уведомить агрегат, что он больше не нужен; 2) запросить интерфейсные указатели при выделении их клиентам главного объекта. На деле результатом приведенной выше реализации QueryInterface будет бесконечный цикл, поскольку внешний объект делегирует функции внутреннему, который делегирует их обратно внешнему.

Для решения этой проблемы необходимо сделать так, чтобы начальный интерфейсный указатель, который возвращается внешнему объекту, не делегировал вызовы реализации IUnknown внешнего объекта. Это означает, что объекты, поддерживающие СОМ- агрегирование, должны иметь две реализации IUnknown. Делегирующая, то есть передающая функции, реализация переадресовывает все запросы QueryInterface, AddRef и Release внешней реализации. Это и есть реализация по умолчанию, на которую ссылаются таблицы vtbl всех объектов, и это именно та версия, которую видят внешние клиенты. Объект должен также иметь неделегирующую реализацию IUnknown, которая выставляется только агрегирующему внешнему объекту.

Имеется несколько возможностей обеспечить две различные реализации IUnknown от одного объекта. Самый прямой путь¹ - это использование композиции и элемента данных для реализации неделегирующих методов IUnknown. Ниже показана реализация Car, поддающаяся агрегации:

class Car : public ICar {
    LONG m_cRef;
    IUnknown *m_pUnk0uter;
  public:
    Car(IUnknown *pUnk0uter);
      // non-delegating IUnknown methods 
      // неделегирующие методы IUnknown 
    STDMETHODIMP InternalQueryInterface(REFIID, void **);
    STDMETHODIMP (ULONG) InternalAddRef(void);
    STDMETHODIMP_(ULONG) InternalRelease(void);
      // delegating IUnknown methods
      // делегирующие методы IUnknown
    STDMETHODIMP QueryInterface(REFIID, void **);
    STDMETHODIMP_(ULONG) AddRef(void);
    STDMETHODIMP_(ULONG) Release(void);
    STDMETHODIMP GetMaxSpeed(*long *pn);
    STDMETHODIMP Brake(void);
      // composite to map distinguished IUnknown vptr to
      // non-delegating InternalXXX routines 1n main object
      // композит для преобразования определенного vptr IUnknown
      // в неделегирующие подпрограммы InternalXXX в главном
      // объекте

    class XNDUnknown : public IUnknown {
        Car* This() 
          { return (Car*)((BYTE*)this - offsetof(Car, m_innerUnknown));} 
        STDMETHODIMP QueryInterface(REFIID r, void**p) 
          { return This()->InternalQueryInterface(r,p); } 
        STDMETHODIMP_(ULONG) AddRef(void) 
          { return This()->InternalAddRef(); } 
        STDMETHODIMP_(ULONG) Release(void) 
          { return This()->InternalRelease(); }
    };

    XNDUnknown m_innerUnknown;
      // composite instance 
      // экземпляр композита 
};

Двоичное размещение этого объекта показано на рис. 4.8. Методы делегирования класса чрезвычайно просты:

STDMETHODIMP Car::QueryInterface(REFIID riid, void **ppv) 
{
    return m_pUnkOuter->QueryInterface(riid, ppv); 
}

STDMETHODIMP_(ULONG) Car::AddRef(void) 
{ 
    return m_pUnkOuter->AddRef(); 
}

STDMETHODIMP_(ULONG) Car::Release (void) 
{ 
    return m_pUnkOuter->Release(); 
}

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

Для того чтобы объект можно было использовать в обоих сценариях - агрегирования и автономном - разработчик объекта должен установить свой элемент данных m_pUnkOuter так, чтобы в случае автономного режима он указывал на собственный неделегирующий IUnknown:

Car::Car(IUnknown *pUnkOuter)
{
    if (pUnkOuter)
      // delegate to pUnkOuter 
      // делегируем в pUnkOuter
        m_pUnkOuter = pUnkOuter;
    else
      // delegate to non-delegating self 
      // делегируем неделегирующему себе 
        m_pUnkOuter = &m_innerUnknown;
}

Разработчик обеспечивает то, что в обоих случаях m_pUnkOuter указывает на нужную для данного объекта реализацию QueryInterface, AddRef и Release.

Обычные неделегирующие реализации QueryInterface, AddRef и Release являются вполне правильными и предсказуемыми:

STDMETHODIMP Car::InternalQueryInterface(REFIID riid, void **ppv) 
{
    if (riid == IID_IUnknown)
        *ppv = static_cast<IUnknown*>(&m_innerUnknown);
    else if (riid = IID_IVehicle)
        *ppv = static_cast<IVehicle*>(this);
    else if (riid == IID_ICar)
        *ppv = static_cast<ICar*>(this);
    else
        return (*ppv = 0), E_NOINTERFACE;
    ((IUnknown*)*ppv)->AddRef();
    return S_OK;
} 

STDMETHODIMP_(ULONG) Car::InternalAddRef(void) 
{
    return InterlockedIncrement(&m_cRef);
} 

STDMETHODIMP_(ULONG) Car::InternalRelease(void)
{
    ULONG res = InterlockedDecrement(&m_cRef);
    if (res == 0) delete this;
    return res;
}

Единственной отличительной особенностью этих трех методов (кроме их имен) является то, что InternalQueryInterface при запросе IUnknown возвращает указатель на неделегирующую Unknown. Это просто требование Спецификации СОМ, которого следует придерживаться.

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

STDMETHODIMP CarClass::CreateInstance(IUnknown *punk0uter, REFIID riid, void **ppv)
{
      // verify that aggregator only requests IUnknown as
      // initial interface 
      // проверяем, что агрегатор только запрашивает IUnknown как
      // начальный интерфейс 
    if (pUnkOuter != 0 && riid != IID_IUnknown)
        return (*ppv = 0), E_INVALIDARG;
      // create new object/aggregate 
      // создаем новый объект или агрегат
    Car *р = new Car(pUnkOuter);
    if (!p) return (*ppv = 0), E_OUTOFMEMORY;
      // return resultant pointer
      // возвращаем результирующий указатель
    p->InternalAddRef();
    HRESULT hr = p->InternalQueryInterface(riid, ppv);
    p->InternalRelease();
    return hr;
}

Отметим, что здесь используются неделегирующие версии QueryInterface, AddRef и Release. Если создается автономная идентификационная единица, то это, конечно, допустимо. Если же создается агрегат, то необходимо убедиться, что AddRef обработал внутренний, а не внешний объект. Отметим также, что внешний объект в качестве начального интерфейса должен запросить IUnknown. Все это регламентировано Спецификацией СОМ. Если бы внешний объект мог запрашивать произвольный начальный интерфейс, то внутреннему объекту пришлось бы хранить два дублирующих набора указателей vptr: один набор делегировал бы свои реализации QueryInterface, AddRef и Release, а другой - нет. При допущении в качестве начального интерфейса одного IUnknown разработчик объекта может выделить только один vptr, который будет действовать как неделегирующий IUnknown.

При программировании с СОМ-агрегированием может возникнуть опасность, связанная со счетчиком ссылок. Отметим, что разработчик внутреннего объекта дублирует указатель на управляющий внешний объект, но не вызывает AddRef. Вызов AddRef в данной ситуации запрещен, поскольку если оба объекта будут обрабатывать друг друга посредством AddRef, то получится бесконечный цикл. Правила подсчета ссылок при агрегировании требуют, чтобы внешний объект хранил указатель на внутренний неделегирующий IUnknown объекта (это указатель, возвращенный подпрограммой создания объекта) после подсчета ссылок на этот указатель. Внутренний объект хранит указатель на IUnknown управляющего внешнего объекта с неподсчитанными ссылками. Формально эти соотношения зафиксированы в специальной формулировке правил СОМ для счетчиков ссылок. Вообще-то методику использования указателей без подсчета ссылок применять нельзя, поскольку ее невозможно реализовать в случае удаленного доступа к объектам. Более эффективный способ избежать зацикливания счетчика ссылок состоит в том, чтобы ввести промежуточные идентификационные единицы (identities) объектов, счетчики ссылок которых не повлияют на время жизни никакого объекта.

Еще одна проблема при программировании агрегирования может возникнуть, когда необходимо связать между собой внутренний и внешний объекты. Для того чтобы организовать связь внутреннего объекта с внешним, нужно вызвать QueryInterface посредством управляющего IUnknown. Однако этот запрос QueryInterface вызовет AddRef через результирующий указатель, который имеет обыкновение без спросу обрабатывать внешний объект с помощью AddRef. Если бы внутренний объект хранил этот указатель в качестве элемента данных, то возник бы цикл, поскольку внутренний объект уже неявно обработал внешний объект с помощью AddRef. Это означает, что внутренний объект должен избрать одну из двух стратегий. Внутренний объект может получать и освобождать указатель по потребности, храня его ровно столько времени, сколько это необходимо:

STDMETHODIMP Inner::MethodX(void) 
{
    ITruck *pTruck = 0;
      // outer object will be AddRefed after this call... 
      // после этого вызова внешний объект будет обработан 
      // с помощью AddRef... 
    HRESULT hr = m_pUnkOuter->QueryInterface(IID_ITruck, (void**)&pTruck);
    if (SUCCEEDED(hr)) { 
        pTruck->ShiftGears();
        pTruck->HaulDirt();
          // release reference to outer object 
          // освобождаем ссылку на внешний объект 
        pTruck->Release();
    } 
}

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

HRESULT Inner::Initialize(void) 
{
    // outer object will be AddRefed after this call... 
    // после этого вызова внешний объект будет обработан 
    // с помощью AddRef... 
    HRESULT hr = m_pUnkOuter->QueryInterface(IID_ITruck, (void**)&m_pTruck);
    // release reference to outer object here and DO NOT 
    // release it later in the object's destructor 
    // освобождаем здесь ссылку на внешний объект и 
    // НЕ ОСВОБОЖДАЕМ ее потом в деструкторе объекта 
    if (SUCCEEDED(hr)) 
        m_pTruck->Release();
}

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

Объекты, которые агрегируют другие объекты, должны быть в курсе проблем, возникающих при запросе интерфейсных указателей внутренними объектами агрегата. В дополнение к уже сделанному предостережению относительно отделяемых интерфейсов отметим еще одну возможную опасность, связанную со стабилизацией объекта. Когда клиенты обращаются к объекту, он должен находиться в стабильном состоянии. В частности, его счетчик ссылок не должен равняться нулю. В общем случае это не является проблемой, так как клиенты могут получать интерфейсные указатели только через QueryInterface, который всегда освобождает AddRef раньше, чем возврат. Однако если объект создает агрегат в своем разработчике, в то время как его счетчик ссылок объекта равен нулю, то программа инициализации внутреннего объекта, показанная выше, освободит завершающее освобождение внешнего объекта, побуждая тем самым внешний объект к преждевременному самоуничтожению. Чтобы устранить эту проблему, объекты, агрегирующие другие объекты, временно увеличивают свои счетчики ссылок на единицу на время создания агрегируемых объектов:

Outer::Outer(void) 
{
    ++m_cRef;
      // protect against delete this
      // защищаем против удаления this
    CoCreateInstance(CLSID_Inner, this, CLSCTX_ALL, 
                     IID_IUnknown, (void**)&m_pUnkInner);
    --m_cRef;
      // allow delete this
      // позволяем удалить this
}

Данная методика стабилизации предотвращает преждевременное разрушение, когда внутренний объект освобождает указатели, которые он, быть может, получил в свой код инициализации. Эта методика настолько общепринята, что большинство СОМ-оболочек программирования включают в себя явный метод перекрытия (overridable), который работает внутри области действия пары инкремент/декремент. В MFC (Microsoft Foundation Classes - библиотека базовых классов Microsoft) этот метод называется CreateAggregates, в ATL - FinalConstruct.

Поскольку показанные выше методики реализации агрегируемого объекта не требуют никаких дополнительных базовых классов, кроме классов C++, то альтернативная форма макроса IMPLEMENT_UNKNOWN может прозрачно реализовать раздвоенную реализацию IUnknown. Определение исходного класса:

class Car : public ICar {
    Car(void);
    IMPLEMENT_UNKNOWN(Car) 
    BEGIN_INTERFACE_TABLE(Car)
    IMPLEMENTS_INTERFACE(ICar)
    IMPLEMENTS_INTERFACE(IVehicle)
    END_INTERFACE()
      // IVehicle methods 
      // методы IVehicle 
    STDMETHODIMP GetMaxSpeed(long *pn);
      // ICar methods 
      // методы ICar 
    STDMETHODIMP Brake(void);
};

просто переводится в следующее:

class Car : public ICar {
    Car(void);
     //indicate that aggregation is required 
     // показываем, что требуется агрегирование 
    IMPLEMENT_AGGREGATABLE_UNKNOWN(Car) 
    BEGIN_INTERFACE_TABLE(Car)
      IMPLEMENTS_INTERFACE(ICar)
      IMPLEMENTS_INTERFACE(IVehicle) 
    END_INTERFACE()
      // IVehicle methods 
      // методы IVehicle 
    STDMETHODIMP GetMaxSpeed(long *pn);
      // ICar methods 
      // методы ICar 
    STDMETHODIMP Brake(void);
};

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

Включение
Где мы находимся?