Passing C++ Object in ATL DLL Server

• Download source files - 38.2 Kb

Introduction

Few weeks ago, I was desperately looking for a sample in which a C++ object can be sent across a COM interface, but could not get any sample for the same. That�s why I decided to post this article here.

Passing C++ Object Across ATL DLL is not difficult but of course a bit tricky and interesting too.

Before starting, make sure that your client and server both must be C++. Secondly, you must be aware of setting COM client and server.

Limitation with Interface

COM demands high degree of separation between client and server which is done through interfaces. But the problem is, interfaces offer only limited number of data types in methods. If the interface is IDispatch based, then the choices are even more limited. Keeping these limitations, C++ object only can be passed across interfaces under these situations:

1. Both client and server are written in VC++.
2. They must be able to share object definitions (i.e. header files).
3. Passing objects simplify the application design.
4. Your application may need to run in a distributed environment. You want COM�s capabilities of remote activation, local/remote transparency and security.

I would recommend that before starting your work, you should also refresh the serialization topic first.

Now let�s continue with the sample and do the following:

1. Create an ATL DLL Server.
2. Add MFC class derived form CObject.
3. Use DECLARE_SERIAL macro in class header.
4. Use IMPLEMENT_SERIAL macro in class body.
5. Override the Serialize() method.

   // Your CSimpleObj class look like this
   
   class CSimpleObj : public CObject  
   {
       DECLARE_SERIAL( CSimpleObj )
   public:
       // constructor and destructor
   
       CSimpleObj();
       virtual ~CSimpleObj();
       // Set internal string data
   
       void SetString( CString csData );
       // Used to serialize data into an archive
   
       virtual void Serialize(CArchive& ar);
       // Display the data string
   
       void Show();
   private:
       CString m_strData;// Internal data string
   
   };

   // Write this object to an archive
   
   void CSimpleObj::Serialize(CArchive& ar)
   {
       CObject::Serialize( ar );
   
       if (ar.IsLoading())
       {
           // extract data from archive
   
           ar >> m_strData;
       }
       else
       {
           // store data into archive
   
           ar << m_strData;
       }
   }

   // Method to display data in this object
   
   void CSimpleObj::Show()
   {
       AfxMessageBox(m_strData);
   }
   
   // save a string in data member
   
   void CSimpleObj::SetString(CString csData)
   {
       m_strData = csData;
   }

   Next step is serializing and de-serializing (loading and storing objects) with a CArchive. I'm using a different class called CBlob for it.

   class CBlob  
   {
   public:
       CBlob() {};
       virtual ~CBlob() {};
   
       // Extract data from a CObject and load it into a SAFEARRAY.
   
       SAFEARRAY* Load( CObject *pObj );
       // Re-create an object from a SAFEARRAY
   
       BOOL Expand( CObject * &pObj, SAFEARRAY *pVar );
   private:
   };

   // Extract data from a CObject and use it to create a SAFEARRAY.
   
   SAFEARRAY* CBlob::Load( CObject *pObj)
   {
       CMemFile memfile;   // memory file
   
   
       // define the flag which tells archive if it should load or store
   
       long lMode = CArchive::store | CArchive::bNoFlushOnDelete;
       // create the archive using the memory file
   
       CArchive ar(&memfile, lMode );
   
       // m_pDocument is not used
   
       ar.m_pDocument = NULL;
       // serialize the object into the archive
   
       ar.WriteObject(pObj);
       // close the archive - the data is now stored in memfile
   
       ar.Close();
   
       // get the length (bytes) of the memory file
   
       long llen = memfile.GetLength();
   
       // detach the buffer and close the file
   
       unsigned char *pMemData = memfile.Detach();
   
       // set up safearray
   
       SAFEARRAY *psa;
   
       // create a safe array to store the stream data
   
       psa = SafeArrayCreateVector( VT_UI1, 0, llen );
   
       // pointers to byte arrays
   
       unsigned char *pData = NULL;
   
       // get a pointer to the safe array. Locks the array.
   
       SafeArrayAccessData( psa, (void**)&pData );
   
       // copy the memory file into the safearray
   
       memcpy( pData, pMemData, llen );
   
       // clean up buffer
   
       delete pMemData;
   
       // unlock access to safearray
   
       SafeArrayUnaccessData(psa);
   
       // return a pointer to a SAFEARRAY allocated here
   
       return psa;
   }

   // Re-create an object from a SAFEARRAY
   
   BOOL CBlob::Expand(CObject * &rpObj, SAFEARRAY *psa)
   {
       CMemFile memfile;   // memory file for de-serailze
   
       long lLength;     // number of bytes
   
       char *pBuffer;  // buffer pointer
   
   
       // lock access to array data
   
       SafeArrayAccessData( psa, (void**)&pBuffer  );
   
       // get number of elements in array. This is the number of bytes
   
       lLength = psa->rgsabound->cElements;
   
       // attach the buffer to the memory file
   
       memfile.Attach((unsigned char*)pBuffer, lLength);
   
       // start at beginning of buffer
   
       memfile.SeekToBegin();
   
       // create an archive with the attached memory file
   
       CArchive ar(&memfile, CArchive::load | CArchive::bNoFlushOnDelete);
   
       // document pointer is not used
   
       ar.m_pDocument = NULL;
   
       // inflate the object and get the pointer
   
       rpObj = ar.ReadObject(0);
   
       // close the archive
   
       ar.Close();
   
       // Note: pBuffer is freed when the SAFEARRAY is destroyed
   
       // Detach the buffer and close the file
   
       pBuffer = (char*) memfile.Detach();
   
       // release the safearray buffer
   
       SafeArrayUnaccessData( psa );
   
       return TRUE;
   }

I'm using SAFEARRAY here because this is the best selection for our use. It can contain some complex multidimensional arrays, but for this example, we are only using a very simple array.

There�s one problem with SAFEARRAY data, that MIDL doesn�t recognize this data type. But the easiest way is VARIANT type that I will discuss in the next article.

Next steps are as follows:

1. Create a COM Interface
2. Create a SAFEARRAY object
3. Define [helpstring("method SetArray")] HRESULT SetArray([in]SAFEARRAY (unsigned char) pData);[helpstring("method GetArray")] HRESULT GetArray([out/*,retval*/]SAFEARRAY(unsigned char) *pData); in IDL file.
4. Make MFC based client to test the application.

Your IDL file should look like this:

    interface IBolbData : IUnknown
    {
        [helpstring("method SetArray")] HRESULT 
            SetArray([in]SAFEARRAY (unsigned char) pData);
        [helpstring("method GetArray")] HRESULT 
            GetArray([out/*,retval*/]SAFEARRAY(unsigned char) *pData);
    };

// Sets object.

STDMETHODIMP CBolbData::SetArray(SAFEARRAY *pData)
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState())

  // create a dummy pointer of CSimpleObj

    CSimpleObj *dummy=NULL; 
    // create blob obect to expand/deserialize 

  CBlob blob;             
  // Init dummy object using safe array through this function

    blob.Expand( (CObject*&)dummy, pData );
  dummy->Show(); // Call show function to test the object.

  delete dummy;  // Delete the pointer.


    return S_OK;
}


// Creates Object and sends to client.

STDMETHODIMP CBolbData::GetArray(SAFEARRAY **pData)
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState())
    // create object to send to server

    CSimpleObj *pMyOb = new CSimpleObj();

    // set the string data

    pMyOb->SetString( "A SAFEARRAY from the server!" );

    // create blob to serialize object

    CBlob blob;

    // load the object into the blob

    *pData = blob.Load( pMyOb );
    // delete the pMyOb pointer 

  delete pMyOb;

  return S_OK;
}

And finally, write a dialog based MFC application having two buttons and add the following code:

void CClientDlg::OnOK() 
{
    // create COM smart pointer from CLSID string

    try
  {
    IBolbDataPtr pI( "Server.BolbData.1" );
        SAFEARRAY *psa ;

        // Get the safearray from the server

        pI->GetArray( &psa );

        // create a pointer to an object

        CSimpleObj *dummy=NULL;

        // blob object to expand 

        CBlob blob;

        // use the blob to expand the safearray into an object

        blob.Expand( (CObject *&)dummy, psa );
        // call a method on the object to test it

        dummy->Show();

        // delete the object

        delete dummy;
    }
    // Handle any COM exceptions from smart pointers

    catch (_com_error e)
    {
        // display the message string from the error

        AfxMessageBox( e.ErrorMessage() );
    }
}

void CClientDlg::OnLoad() 
{
    try
    {
        // create smart pointer from CLSID string

        IBolbDataPtr pI( "Server.BolbData.1" );
        SAFEARRAY *psa ;

        // create object to send to server

        CSimpleObj *pMyOb = new CSimpleObj();

        // set the string data

        pMyOb->SetString( "The client sent a SAFEARRAY!" );

        // create blob to serialize object

        CBlob blob;

        // load the object into the blob

        psa = blob.Load( pMyOb );

        // delete the object

//        delete pMyOb;


        pI->SetArray( psa );

    }
    // Handle any COM exceptions from smart pointers

    catch (_com_error e)
    {
        // display the message string from the error

        AfxMessageBox( e.ErrorMessage() );
    }
}

Conclusion

This article covers a number of topics i.e. how to use serialization, how to use SAFEARRAY and how to pass a C++ object across the interface. I also would like to say thanks to William Rubin whose article helped me quite a lot. I was planning to explain this topic in a bit more detail but due to shortage of time I couldn�t do so but will keep updating the document from time to time. In the mean time, please feel free to contact me.