Marshaling Classes

Objective Toolkit User's Guide
Rogue Wave web site: Home Page | Main Documentation Page

30.15 Marshaling Classes

From time to time, COM developers need to move an interface pointer from one apartment to another (for example, if two threads need access to the same object). The process of getting an interface pointer from one apartment to another is called marshaling the interface pointer.

OTL provides marshaling help in several forms. First, OT/ATL contains a class named OtlGIT to help you work with the Global Interface Table. The OtlGIT class manages the IGlobalInterfaceTable interface for you so you no longer need to call CoCreateInstance() to retrieve the interface.

Here's an example illustrating how to use the global interface helper.

#include <OtlGIT.h>

using namespace StingrayOTL;

OtlGIT* potlgit;

DWORD g_dwMarshalThis = 0;

DWORD WINAPI ThreadProc(void *pv)
{
  IMarshalThis* pMarshalThis = NULL;
    HRESULT hr = CoInitializeEx(0, 
                COINIT_APARTMENTTHREADED);

  IMarshalThis* pRaw = (IMarshalThis*)pv;

  if(pRaw) 
  {
    hr = pRaw->Method2(3);
    if(FAILED(hr)) 
    {
      printf("Raw pointer didn't work \n");
    } else
    {
      printf("Raw pointer did work \n");
      pRaw->Release();
    }
  }

// Unmarshal the interface pointerfrom the GIT
  hr = potlgit->GetInterface(g_dwMarshalThis, 
                    IID_IMarshalThis, 
                    (void**)&pMarshalThis);

  if(SUCCEEDED(hr)) 
  {
    short s;

// Use the pointer
    hr = pMarshalThis->Method1(34, &s);
    if(SUCCEEDED(hr)) 
    {
      printf("Marshaled pointer did work \n");
    } else
    {
      printf("Marshaled pointer didn't work \n");
    }

// Release the interface pointers.
      pMarshalThis->Release();
  }

// Leave the apartment.    
    CoUninitialize();
    return 0;
}

int main(int argc, char* argv[])
{
  // Enter the multi-threaded apartment. We're all partying in
  // the same room now.
  CoInitializeEx(0, COINIT_MULTITHREADED);

  IMarshalThis* pMarshalThis = NULL;

  potlgit = new OtlGIT;
  if(!potlgit)
    return 0;

  // CoCreateInstance on the SomeATLObj
  HRESULT hr = CoCreateInstance(CLSID_MarshalThisObj, 
                      NULL, 
                      CLSCTX_INPROC_SERVER,
                      IID_IMarshalThis,
                      (void**)&pMarshalThis);

  if(SUCCEEDED(hr)) {
    // Register the interface pointer with the global
    // interface table
    potlgit->RegisterInterface(pMarshalThis,
                            IID_IMarshalThis,
                            &g_dwMarshalThis);

    // go ahead and call these functions from this apartment.
    // Then create a new thread in a new apartment
      DWORD dwTID;
      HANDLE hthread = CreateThread(0, 0, 
                        ThreadProc, 
                        pMarshalThis, 
                        0, &dwTID);

    // Wait for the thread to exit and close the handle.
    // allow STA to dispatch calls
    AtlWaitWithMessageLoop( hthread );
    CloseHandle(hthread);

    pMarshalThis->Release();
    potlgit->RevokeInterface(g_dwMarshalThis);

  } else
  {
    printf("Couldn't create CLSID_MarshalThisObj\n");
  }

  if(potlgit)
  {
    delete potlgit;
  }

  printf( "\nPress any key to exit..." );
  getchar();

  CoUninitialize();
  return 0;
}

The Rogue Wave name and logo, and Stingray, are registered trademarks of Rogue Wave Software. All other trademarks are the property of their respective owners.
Provide feedback to Rogue Wave about its documentation.