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

Специальный маршалинг

До сих пор внимание в данной главе было сосредоточено на стандартном маршалинге и вызове методов на основе ORPC. Для большого класса объектов этого было достаточно, чтобы достичь нужного баланса между производительностью, семантической корректностью и простотой реализации. В то же время существуют объекты, для которых ORPC-вызов по умолчанию является неэффективным и даже непригодным. Для таких объектов в СОМ предусмотрен специальный маршалинг (custom marshaling). Как уже упоминалось в этой главе, специальный маршалинг позволяет разработчику объекта обеспечить реализацию специальных заместителей (custom proxies), которые будут созданы в импортирующих апартаментах. Объекты сообщают о своем желании поддерживать специальный маршалинг путем экспорта интерфейса IMarshal:

[uuid(00000003-0000-0000-C000-000000000046), local, object]
  interface IMarshal : IUnknown {

  // get CLSID for custom proxy (CoMarshalInterface)
  // получаем CLSID для специального заместителя (CoMarshalInterface)
  HRESULT GetUnmarshalClass(
           [in] REFIID riid, [in, iid_is(riid) ] void *pv,
           [in] DWORD dwDestCtx, [in] void *pvDestCtx,
           [in] DWORD mshlflags, [out] CLSID *pclsid);

  // get size of custom marshaled objref (CoGetMarshalSizeMax)
  // получаем размер специально маршалированной объектной ссылки (CoGetMarshalSizeMax)
  HRESULT GetMarshalSizeMax(
            [in] REFIID riid, [in, iid_is(riid)] void *pv,
            [in] DWORD dwDestCtx, [in] void *pvDestCtx,
            [in] DWORD mshlflags, [out] DWORD *pSize);

  // write out custom marshaled objref (CoMarshalInterface)
  // выполняем контрольное считывание специально маршалированной объектной ссылки (CoMarshalInterface) 
  HRESULT MarshalInterface([in] IStream *pStm,
            [in] REFIID riid, [in, iid_is(riid)] void *pv,
            [in] DWORD dwDestCtx, [in] void *pvDestCtx,
            [in] DWORD mshlflags);

  // read objref and return proxy (CoUnmarshalInterface) 
  // читаем объектную ссылку и возвращаем заместитель

  // ( CoUnmarshalInterface)
  HRESULT UnmarshalInterface([in] IStream *pStm, 
                           [in] REFIID riid,
                           [out, iid_is(riid)] void **ppv);

  // revoke a marshal (CoReleaseMarshalData) 
  // аннулируем маршалер (CoReleaseMarshalData) 
  HRESULT ReleaseMarshalData([in] IStream *pStm);

  // tear down connection-state (CoDisconnectObject) 
  // разрываем связь между объектами (CoDisconnectObject) 
  HRESULT DisconnectObject([in] DWORD dwReserved);
}

Комментарии, предваряющие определения методов, показывают, какие именно API-функции вызывает каждый из них.

Когда метод CoMarshalInterface вызывается на объект, поддерживающий специальный маршалинг, маршалированная объектная ссылка имеет несколько другой (формат, как показано на рис. 5.7. Заметим, что после стандартного заголовка MEOW маршалированная объектная ссылка просто содержит CLSID, используемый для создания специального заместителя и непрозрачного байтового массива, предназначенного для инициализации этого специального заместителя. CoMarshalInterface находит CLSID специального заместителя посредством вызова на объект метода IMarshal::GetUnmarshalСlass. CoMarshalInterface заполняет непрозрачный байтовый массив, вызывая реализацию метода IMarshal::MarshalInterface объекта. Именно в MarshalInterface объект получает свой первый и единственный шанс послать инициализационное сообщение новому специальному заместителю, просто записав его в подаваемый байтовый поток.

При вызове CoUnmarshalInterface это сообщение будет передано вновь созданному специальному заместителю через его метод IMarshal::UnmarshalInterface. Это означает, что и объект, и специальный заместитель должны реализовать IMarshal. Метод объекта MarshalInterface записывает инициализационное сообщение. Метод заместителя UnmarshalInterface читает инициализационное сообщение. Когда метод UnmarshalInterface возвращается, СОМ больше не участвует ни в каких связях заместитель/объект. Реализация интерфейсных методов семантически корректным способом является делом специального заместителя. Если нужно произвести удаленный вызов метода на объект, то сделать это - задача заместителя. Если же метод может быть реализован в апартаменте клиента, то заместитель может сделать и это.

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

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

HRESULT CoGetStandardMarshal(
          [in] REFIID riid, 
             // type of itf marshaled? 
             // тип, которым маршалирован интерфейс?
          [in, iid_is(riid)] IUnknown *pUnk, 
             // the itf to marshal 
             // интерфейс для маршалинга 
          [in] DWORD dwDestCtx, // MSHCTX 
          [in] void *pvDestCtx, 
             // reserved 
             // зарезервировано
          [in] DWORD mshlflags, 
             // normal vs. table 
             // нормальный или табличный маршалинг
          [out] IMarshal **ppMarshal);
             // ptr to std. Marshal 
             // указатель на стандартный маршалер

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

STDMETHODIMP CustStd::GetMarshalSizeMax(
                ULONG *pcb, 
                REFIID riid, 
                void *pv, 
                DWORD dwDestCtx, 
                void *pvDestCtx, 
                DWORD mshlflags) 
{ 
    // if context is supported, do work!
    // если контекст поддерживается, то действуем! 

  if (dwDestCtx == MSHCTX_LOCAL || dwDestCtx == MSHCTX_INPROC) 
      return this->MyCustomMarshalingRoutine(pcb);

    // unsupported context, delegate to std marshal 
    // контекст не поддерживается, обращаемся к стандартному маршапингу 
  IMarshal *pMsh = 0;
  HRESULT hr = CoGetStandardMarshal (riid, pv, dwDestCtx, pvDestCtx, mshlflags, &pMsh); 
  if (SUCCEEDED(hr)) { 
      hr = pMsh->GetMarshalSizeMax(pcb, riid, pv, dwDestCtx, pvDestCtx, mshlflags); 
      pMsh->Retease();
  }
  return hr;
}

В этом фрагменте кода не показано, как писать инициализационное сообщение для случая, когда действительно желателен специальный маршалинг. Дело в том, что не существует стандартной реализации каждого из методов IMarshal (отсюда и термин специальный (custom) маршалинг). Существует, однако, несколько общих сценариев, в которых специальный маршалинг чрезвычайно выигрышен и реализация IMarshal в этих сценариях - довольно обычное явление. Безусловно, наиболее общим приложением IMarshal является реализация маршалинга по значению (marshal-by-value).

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

Представим следующее определение класса СОМ-обертки вокруг простой двумерной точки:

class Point : public IPoint, public IMarshal {
    long m_x; long m_y; 
  public:
    Point(void) : m_x(0), m_y(0) {} 
    IMPLEMENT_UNKNOWN (Point) 
    BEGIN_INTERFACE_TABLE(Point) 
      IMPLEMENTS_INTERFACE(IPoint) 
      IMPLEMENTS_INTERFACE(IMarshal) 
    END_INTERFACE_TABLE() 
      // IPoint methods 
      // методы IPoint 
      // IMarshal methods
      // методы IMarshal
};

Для поддержки маршалинга по значению метод MarshalInterface класса должен преобразовать состояние объекта в последовательную форму в качестве инициализационного сообщения для заместителя:

STOMETHODIMP Point::MarshalInterface(IStream *pStm, REFIID,
                    void *, DWORD, void *, DWORD) 
{ 
      // write out endian header 
      // переписываем завершающий заголовок 
    DWORD dw = OxFF669900;
    HRESULT hr = pStm->Write(&dw, sizeof(DWORD), 0);
    if (FAILED(hr)) return hr;
    dw = m_x;
    hr = pStm->Write(&dw, sizeof(DWORD), 0);
    if (FAILED(hr)) return hr;
    dw = m_y;
    return pStm->Write(&dw, sizeof (DWORD), 0);
}

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

STDMETHODIMP Point::GetUnmarshalClass(REFIID, void *, DWORD,
                                      void *, DWORD, CLSID *pclsid) 
{
    *pclsid = CLSID_Point;
      // this class's CLSID 
      // CLSID этого класса 
    return hr;
}

Для обеспечения того, чтобы для инициализационного сообщения было выделено достаточно места, методу объекта GetMarshalSizeMax требуется возвратить правильное количество байт:

STDMETHODIMP Point::GetMarshalSizeMax(REFIID, void *, DWORD, 
                                      void *, DWORD, DWORD *pcb) 
{
    *pcb = 3 * sizeof (DWORD);   // m_x + m_y + header 
    return hr;
}

Когда маршалированная объектная ссылка демаршалируется с помощью CoUnmarshalInterface, тот факт, что она была маршалирована специальным образом, вызовет создание нового специального заместителя. Объектная ссылка содержит CLSID специального заместителя, возвращенный исходным объектом в своем методе GetUnmarshalClass. Когда создан новый специальный заместитель, его метод UnmarshalInterface получает инициализационное сообщение, которое объект записал в своей реализации MarshalInterface:

STDMETHODIMP Point::UnmarshalInterface(IStream *pStm,
                                       REFIID riid, void ** ppv) 
{ 
    *ppv = 0;
      // read endian header 
      // читаем заключительный заголовок 
    DWORD dw; 
    ULONG cbRead;
    HRESULT hr = pStm->Read(&dw, sizeof (DWORD), &cbRead);
    if (FAILED(hr) || cbRead != sizeof(DWORD))
        return RPC_E_INVALID_DATA;
    bool bSwapEndian = dw == 0x009966FF; 
      // read m_x and m_y 
      // читаем m_x и m_y 
    hr = pStm->Read(&dw, sizeof(DWORD), &cbRead); m_x = dw;
    if (FAILED(hr) || cbRead != sizeof(DWORD))
        return RPC_E_INVALID_DATA; 
    hr = pStm->Read(&dw, sizeof(DWORD), &cbRead); m_y = dw;
    if (FAILED(hr)) || cbRead != sizeof(DWORD))
        return RPC_E_INVALID_DATA; 
      // byte swap members if necessary 
      // байт переставляет свои биты, если необходимо 
    if (bSwapEndian)
        byteswapdata(&m_x, &m_y);
      // return pointer to this object 
      // возвращаем указатель на этот объект 
    return this->QueryInterface(riid, ppv);
}

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

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

Маршалер свободной поточной обработки (FreeThreaded Marshaler)
Где мы находимся?