CoInitialize[ex]/CoUnitialize calls

[@nthony]

For an application that makes little use of COM, where is the most effecient place to make the CoInitialize/Unitialize calls?

Currently I use COM only briefly in a modal dialog and CoInitialize it in the WM_CREATE message, CoUnitializing it on WM_NCDESTROY. However the literature is a bit ambiguous as to if this is a good strategy. Some sources say this is an effective way to reduce memory usage by COM (versus placing the calls at program init/end), others say there may be time required between the init call and when it is actually initialized, making calls in between them prone to error.

So where is a good place for these calls to both limit resources used and still ensure COM is intialized properly?

[Sebastiani]

Personally, I would use the program entry/exit strategy to reduce the chance of any latency issues cropping up. If you're using C++ you could even wrap it up into a class and have everything happen automagically.

[@nthony]

The difference in memory between the two methods is 10 K before a COM call and about 1 MB after, I'll keep trying other placements and see what happens.

[novacain]

For an application that makes little use of COM, where is the most effecient place to make the CoInitialize/Unitialize calls?

Currently I use COM only briefly in a modal dialog and CoInitialize it in the WM_CREATE message, CoUnitializing it on WM_NCDESTROY. However the literature is a bit ambiguous as to if this is a good strategy. Some sources say this is an effective way to reduce memory usage by COM (versus placing the calls at program init/end), others say there may be time required between the init call and when it is actually initialized, making calls in between them prone to error.

So where is a good place for these calls to both limit resources used and still ensure COM is intialized properly?

I have had issues with COM not freeing resources quickly enough, causing the next call to COM to fail as out of memory (but in XPe with EWF).

Depends on how often / quickly the dlg can be called and how quickly COM will be required after create.
It may be that a small Sleep() will fix any issue (while waiting for COM to finish)
or
CoInitialize may have to be called at app create (not dlg create).

IMO only call CoInitialize once for the app / threads lifetime.

[adeyblue]

On Win7 once you initialize COM, there's 261KB of memory allocated that you'll never get back, no matter how many calls to CoUninitialize() you make. This "leak" is present on earlier versions of Windows too but the amount differs. I realize that's nothing nowadays, just thought it might interest the OP as I remember a previous thread on the tightness of MS's code.

Oh and the app that produced that trace was just:

int main()
{
    CoInitialize(NULL);
    CoUninitialize();
    ExitProcess(0);
}