출처 :  https://wiert.me/2016/02/03/windows-vista78-hangs-for-windows-common-dialogs-when-your-com-initialisation-is-wrong/

A while ago I bumped into this: As of Windows 7 (and probably Vista), the standard Windows Common Item (Open and Save) Dialogs expect the main thread to be initialised with STA because it is easier to support apartment threading in single-threaded apartments because COM provides synchronization on a per-call basis and the Windows GUI APIs are not guaranteed to be thread safe.

Windows XP and Server 2003 didn’t enforce this for the classic Windows Open and Save Dialogs, so it only appeared when the software below got run on Windows 7 in a way too late time frame (but the market share of XP is still high).

The reason is that when using Delphi, the TOpenDialog and TSaveDialog will use the classic Open and Save Dialogs on Windows < Vista and fall-forward to the new Common Item Dialogs handled by TFileOpenDialog and TFileSaveDialog (both will not fall backward).

When you have your COM initialisation done wrong, your application appears to hang. Amidst the plethora of threads started by the COM subsystem, these two dead-lock:

Example code to reproduce this is in my BeSharp.net repository.

The hang in the main thread is on this line of code in the below fragement:

Result := Succeeded(Show(ParentWnd)); //// <—- hangs here

Thanks to the help on G+ it was easy to track down it was indeed a COM issue.

The DLLs ole32.dll and actxprxy.dll sort of give it away: OLE and COM ActiveX proxy.

And indeed: the code contained this (for someone in the community familiar because he copy-pasted a Google search result) piece of code running before the Application.Initialize:

procedure TDMConfigMgr.DataModuleCreate(Sender: TObject);
begin
  CoInitializeEx(nil, 0);
  if not xmldoc.Active then
    xmldoc.Active := True;
end;

Solving the symptom was easy, just replace the COM initialisation with this:

CoInitializeEx(nil, COINIT_APARTMENTTHREADED);

But that is not the proper solution. The are is more wrong with the above code:

1. There is no CoUninitialize (see below why this important)
2. The usage of COM and initialization of COM are bound together (so what if someone else needs a different kind of initialisation?)

The proper solution is to deferring your dependency on the COM initialisation and letting Delphi do the COM initialisation by specifying it in your main project like this:

uses
  Forms,
...
  ActiveX;

{$R *.res}

begin
  CoInitFlags := COINIT_APARTMENTTHREADED;
  Application.Initialize;
...

Replace the COINIT_APARTMENTTHREADED to CoInitFlags with the required threading taking the below information into account so that Application.Initialize will pass it to the COM subsystem in the (undocumented) InitComObj method of the ComObj unit.

If you really need to use MTA, then read the COM FAQs (RemObjects SDK) – RemObjects Wiki about some more details: it’s tricky and complicated.

Background information

On the Delphi side, these by Delphi COM expert Chris Bensen are the canonical posts to get CoInitialize/CoInitializeEx and CoUninitialize right:

• Delphi Tips And Tricks: CoInitialize/CoUninitialize Part I (ensure you don’t have dangling COM references after calling CoUnitialize).
• Chris Bensen: Delphi Tips And Tricks: CoInitialize/CoUninitialize Part II (pair Initialize/Uninitialize calls; nestInitialize/Uninitialize calls properly; each thread needs to Initialize with one model per thread; do not use them in DllMain).
• Chris Bensen: Delphi Tips And Tricks: CoInitialize/CoUninitialize Part III (about MTA: multithreaded apartment; Call CoUnitialize only when CoInitialize(Ex) returns S_OK or S_FALSE).

Read the underlying links for more information; here a quick summary:

CoInitialize/CoInitializeEx/OleInitialize initialize COM for a thread. CoUninitialize unitializes COM for a thread. OleInitialize and the “deprecated” CoInitialize set COM up for STA (Single-Threaded Apartment) mode by calling CoInitializeEx with the COINIT enumeration value COINIT_APARTMENTTHREADED.

A confusion for CoInitializeEx is that passing zero for the COINIT value is COINIT_MULTITHREADED which is not the default that OleInitialize and CoInitialize use.

The COINIT enumeration is a flag, so you can add these values together:

MSDN links:

• Choosing the Threading Model (COM).
• STA: Single-Threaded Apartments (COM): use this if you’re not sure your COM objects are inherently thread safe (COM provides synchronisation).
• MTA: Multithreaded Apartments (COM): also called “free-threaded” use this if you’re sure all your COM objects and code they use are thread safe (COM provides no synchronisation so you’re on your own here).
• CoInitialize function (COM).
• CoInitializeEx function (COM).
• CoUninitialize function (COM).
• COINIT enumeration (COM).
• OleInitialize function (COM).
• Apartments and Pumping in the CLR – cbrumme’s WebLog – Site Home – MSDN Blogs.

SO links:

• c# – Single-Threaded Apartments vs Multi-Threaded Apartments – Stack Overflow.
• .net – Could you explain STA and MTA? – Stack Overflow.
• delphi – What is the difference between the new TFileOpenDialog and the old TOpenDialog? – Stack Overflow.

–jeroen