Question

We are adapting our client side relatively complicated application (ActiveX / .net / Delphi / C++ / COM ) to use SxS to achieve non admin deployment and isolation from older versions of our product.

We were able to achieve this goal for almost all our in proc components such as our .net ui, Delphi ui, and the COM servers we use in proc by composing a manifest file which described all the libraries used by our process, with no registration on the client of any of the components (almost).

And here comes the almost part:
At the moment, our application invokes (from it’s c++ portion) an out of proc ActiveX server (Delphi ActiveX EXE), which in turn itself invokes another set of out of proc ActiveX servers (third party plugins, any thing goes here, Delphi, C++, any thing as long as it’s out of proc ActiveX EXE and implements our interfaces).

As we know SxS does not support out of proc ActiveX servers. And we can’t use these objects as in proc com servers in our main process because that would require a major rewrite of our application and even worst, a break of our public facing API which is used by third party tools and vendors, an api break which we can’t allow.

We have stumbled on this article which describes how IHTMLDocument2 can be extracted from an Internet Explorer window running in a separate process. Which made us think of this approach:

We would create a secondary satellite application / process which will run the ActiveX as in process server.
Then we will use LresultFromObject and ObjectFromLresult to transfer a reference of the ActiveX object from the satellite application to the main application process. The satellite application will have it’s own manifest file which will allow it to run in SxS mode.

Same approach will be taken to communicate between this Delphi ActiveX EXE and the third party AciveX EXE Plugins

There is an alternative solution, which for the moment we do not prefer over the proposed solution above which is to use .net remoting and .net com proxy classes to open the communication channel between the two processes, by translating the com request to .net remoting, and back to com on the second process.

So here comes the question:

1. What do you think about this approach ?
2. Do you see a better solution to the problem ?

Answer 1

It is possible to do. What is needed:

• An application needs to start a server itself rather than relying on COM to do it. You don’t need the extra indirection provided by the registry, just use CreateProcess().
• A server should register its class factories in its main() method with CoRegisterClassObject().
• Important: the CLSID it uses for each factory should be altered to be unique for each service instance. This ensures that the client connects to the correct server. I simply XOR the process ID with a class factory CLSID. The client knows the process ID as well so can make the same alteration.
• The application should call CoCreateInstance() in a loop with a Sleep() call to wait for the object factory to appear. Don’t declare failure until at least 60 seconds have passed (that bit me).
• Both the application and the server need a manifest that contains a <file> element for each proxy/stub DLL and <comInterfaceExternProxyStub> elements for each interface that is remoted.