Re: COM calls reentering in STA
"Igor Tandetnik" <email@example.com> wrote in message
Scott McPhillips [MVP] <org-dot-mvps-at-scottmcp> wrote:
I wrote an exe COM server and its client, which is an Office COM
addin. All unmanaged using ATL. Client and server use STA. The client
initially passes in a callback pointer the server will use to call
its methods. The server is multithreaded so it uses the GIT table to
marshall calls to the client.
STA and multithreaded is an unusual combination, especially for a server.
Are you creating multiple threads, each entering STA? Why don't you just
have them all join MTA? Anyway, that's irrelevant to your main issue.
The problem I have it that calls from
multiple server threads, made to the same client object and method,
reenter in the client instead of waiting until the first call has
Your client methods yield - meaning, do something that causes window
messages to be processed. E.g. this happens if you show a modal dialog box
or a context menu, or make an outgoing cross-apartment COM call. Incoming
cross-apartment COM calls are delivered to an STA apartment in the form of
a custom window message; yielding allows a nested reentrant call to come
See also IMessageFilter.
So I wonder if this is expected behavior.
Yes - and a royal pain to deal with.
The idea that using the
marshalled pointer switches threads so the calls all originate from
one thread may be true behind the scenes
Actually, it doesn't, they don't, and it isn't. None of your many STA
threads on the server is any more special than others. Another way to say
it: marshalling never results in a proxy to a proxy - you always get a
direct proxy to the original object.
but does not seem to be
enough to provide serialization of the calls. Why does the main
thread not wait for the COM call to return before resuming execution?
Which thread is the "main" one?
If COM does not serialize the calls, what do I have to do to
One way would be not to yield in your callback method.
Thank you Igor for letting me know it is "a royal pain to deal with." At
least that suggests my COM setup is working as expected :(
Initially, client calls server passing a pointer to a client callback
object. So the thread that receives this initial call is the "main" and
puts the pointer into the GIT so other threads can use a marshalled pointer.
Your comments make me wonder what the point of the GIT marshalling is.
Anyway, the client is an Office COM addin, so it is dealing with a lot of
unknowns when it calls a function in the host office app. Hard to know what
calls might do a yield. A quick look at IMessageFilter looks real scary: I
don't want to "reject" calls, just make them wait. So it seems to me I will
need to protect all the server's callback calls with a critical section.
Any other possible approaches?
Scott McPhillips [VC++ MVP]