Steps to Reproduce Behavior

1. Create an Automation Server project. Call it "ImportServer". The steps provided here represent an ATL In-Proc Automation Server, so for the ATL COM AppWizard simply accept the defaults and click Finish.
2. Insert a new ATL object and select a Simple Object. Name it Server1.
3. Insert a second ATL object and select Simple Object again. Name it Server2.
4. Add a member variable to Server1 for Server2 as in the following:

   CComObject<CServer2>* m_pServer2;
   					

   Don't forget to include the header file for Server2, and to initialize the pointer in Server1's constructor, or use an initializer.
   
   
5. Override Server1's FinalConstruct() and FinalRelease() methods to create an instance of Server2 when Server1 is created, and destroy the instance when it is destroyed.

   HRESULT FinalConstruct()
   {
       HRESULT hr = CComObject<CServer2>::CreateInstance(&m_pServer2);
       if (SUCCEEDED(hr))
           m_pServer2->AddRef();
       return hr;
   }
   
   void FinalRelease()
   {
       if (m_pServer2)
           m_pServer2->Release();
   }
   					

6. Add a method to Server1 which returns an LPDISPATCH pointer for Server2. The method could be prototyped as follows:

   STDMETHOD(ReturnServer2)(/*[out,retval]*/ LPDISPATCH* ppDisp);
   					

   The implementation simply queries Server2 for its IDispatch interface:

   STDMETHODIMP CServer1::ReturnServer2(LPDISPATCH* ppDisp)
   {
       return m_pServer2->QueryInterface(IID_IDispatch, (void**)ppDisp);
   }
   					

7. Add a method to Server2 so that it can be tested. For this example, add a method which returns a string value, such as:

   STDMETHOD(GetString)(/*[out,retval]*/ BSTR* pstr);
   					

   
   Here is a sample implementation:
   

   STDMETHODIMP CServer2::GetString(BSTR* pstr)
   {
       *pstr = SysAllocString(L"Hello from Server2");
       return S_OK;
   }
   					

8. Create a Win32 Console app to serve as the client. Here is some sample test code:

   #include "stdafx.h"
   
   int main(int argc, char* argv[])
   {
       CoInitialize(NULL);
       {
           IServer1Ptr spServer1;
           spServer1.CreateInstance(__uuidof(Server1)); // for Visual C++ 6.0
           spServer1.CreateInstance(__uuidof(CServer1)); // for Visual C++.NET
           TCHAR szTemp[50];
           for (int i = 0; i < 5; i++)
           {
               LPDISPATCH pDisp = spServer1->ReturnServer2();
               IServer2Ptr spServer2(pDisp);
               BSTR str = spServer2->GetString();
               int nRet = WideCharToMultiByte(0, 0, str, 
                              SysStringLen(str)+1, szTemp, 50,
                              NULL, NULL);
               if (nRet)
               {
                   lstrcat(szTemp, "\n");
                   OutputDebugString(szTemp);
               }
               SysFreeString(str);
               pDisp->Release();
           }
       }
       CoUninitialize();
   	
       return 0;
   }
   					

9. In stdafx.h, import the type library for the server. For example:

   #import "..\ImportServer.tlb" no_namespace // For Visual C++ 6.0
   or
   #import "..\ImportServer.tlb" no namespace // For Visual C++ .NET
   					

10. Compile the server and the client. When the client is executed, an error should occur on creation of spServer2, since pDisp is not valid.
    
    To correct the problem, change the line which calls ReturnServer2 as follows:

    IDispatchPtr spDisp = spServer1->ReturnServer2();
    						

    
    Also, the call to Release() the dispatch pointer should now be removed.
    
    As mentioned previously, the other solution could be to detach the raw dispatch pointer from the smart pointer wrapper:
    

    LPDISPATCH pDisp = spServer1->ReturnServer2().Detach();
    						

    
    If this method is used, then Release() would still need to be called for the Dispatch interface.

Back to the top