{"id":318,"date":"2012-07-28T21:33:07","date_gmt":"2012-07-29T01:33:07","guid":{"rendered":"http:\/\/templesystems.com\/?page_id=318"},"modified":"2012-07-28T21:37:17","modified_gmt":"2012-07-29T01:37:17","slug":"318-2","status":"publish","type":"page","link":"https:\/\/templesystems.com\/?page_id=318","title":{"rendered":"COM Tutorial"},"content":{"rendered":"

COM Tutorial<\/p>\n

\n

<\/a><\/a>COM & ATL<\/span><\/span><\/p>\n

Silan Liu<\/span><\/strong><\/span><\/p>\n

\u00a0<\/span><\/p>\n

<\/a><\/a><\/a><\/a><\/a>1.\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span>COM<\/span><\/span><\/span><\/span><\/span><\/h1>\n

Basics<\/p>\n

<\/a><\/span><\/h1>\n

 <\/p>\n

<\/a><\/a>1.1.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>Service Control Manager (SCM)<\/span><\/h2>\n

A Windows program called Service Control Manager (SCM) does<\/p>\n

most of the job in COM server invoking. It finds the server through System Registry,<\/p>\n

runs it, has it create the COM object, sets up local\/remote transparency, and<\/p>\n

returns an interface pointer to the client.<\/p>\n

Then the client can directly invoke methods of the COM<\/p>\n

object through the pointer, and there is no middleware involved unless it is a<\/p>\n

remote server, in which case only RPC is involved.<\/p>\n

<\/a><\/a>1.2.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>Interface IUnknown<\/span><\/h2>\n

All COM interfaces should inherit interface IUnknown<\/strong>:<\/p>\n

\u00a0<\/span><\/p>\n

interface IUnknown<\/span><\/strong><\/span><\/p>\n

{<\/span><\/p>\n

HRESULT QueryInterface(REFIID iid, void** ppvObject);<\/p>\n

ULONG AddRef();<\/p>\n

ULONG Release();<\/p>\n

}<\/span><\/p>\n

One COM object may be used by multiple clients. The COM<\/p>\n

server maintains a reference count for each interface of the object. When one<\/p>\n

client asks to create an instance of the interface with CoCreateInstance<\/strong><\/p>\n

or CoCreateInstanceEx<\/strong>, the COM server will call that interface\u2019s method AddRef<\/strong><\/p>\n

to increment the reference count.<\/p>\n

When one client is finished with an interface, it should<\/p>\n

call its Release<\/strong> method to decrement the reference count. When the count<\/p>\n

reaches zero, the COM server should destroy the COM object.<\/p>\n

In Visual Basic, a local COM object is automatically<\/p>\n

destroyed when leaving scope. To manually delete an object, say<\/p>\n

\u00a0<\/span><\/p>\n

<\/a>Set objAccount = Nothing<\/span><\/strong><\/span><\/p>\n

<\/a><\/a>1.3.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>Global Unique ID (GUID)<\/span><\/h2>\n

Each coclass and interface has its guid, which is a 128-bit<\/p>\n

number. For easy use by the programmer, an easy-remember manifest constant is<\/p>\n

defined for each guid. In Visual C++ these constants are defined in a header<\/p>\n

file e.g. \u201cBank_i.c\u201d, and some entries look like:<\/p>\n

\u00a0<\/span><\/p>\n

const IID IID_IGreet<\/span><\/strong><\/span><\/p>\n

= {0x7A5E6E81,0x3DF8,0x11D3,{0x90,0x3D,0x00,0x10,0x5A,0xA4,0x5B,0xDC}};<\/p>\n

\u00a0<\/span><\/p>\n

const IID LIBID_BANKLib<\/span><\/strong><\/span><\/p>\n

= {0x0FFBDAA1,0xFCA7,0x11D2,{0x8F,0xF4,0x00,0x10,0x5A,0xA4,0x5B,0xDC}};<\/p>\n

\u00a0<\/span><\/p>\n

const CLSID CLSID_Account<\/span><\/strong><\/span><\/p>\n

= {0x0FFBDAAE,0xFCA7,0x11D2,{0x8F,0xF4,0x00,0x10,0x5A,0xA4,0x5B,0xDC}};<\/p>\n

GUID constants such as IID_IGreet and CLSID_Account are not<\/p>\n

globally unique, but it does not matter because they live only in the scope of<\/p>\n

one application program. The compiler will read the interface definition file<\/p>\n

to convert the constant to the corresponding guid.<\/p>\n

GUIDs for classes are of type CLSID<\/strong>, and all<\/p>\n

variables start with \u201cCLSID_\u201d followed by the class name, such as<\/p>\n

\u201cCLSID_Account\u201d. GUIDs for interfaces are of type IID<\/strong>,and all start with \u201cIID_\u201d followed by the<\/p>\n

interface name such as \u201cIID_IAccount\u201d.<\/p>\n

To convert between CLSID and unicode array:<\/p>\n

\u00a0<\/span><\/p>\n

CLSID clsid;<\/span><\/p>\n

…<\/span><\/p>\n

WCHAR * ostr;<\/span><\/p>\n

HRESULT hr = StringFromCLSID<\/span><\/strong>(clsid,<\/span><\/p>\n

&ostr);<\/p>\n

Program \u201cMicrosoft Visual Studio\\Common\\Tools\\Guidgen.exe<\/strong>\u201d<\/p>\n

is used to generate a guid. Choose the format of the guid and press button<\/p>\n

\u201cCopy\u201d. The generated guid will be in the clipboard.<\/p>\n

You can also add it to the \u201cTools\u201d menu with menu \u201cTools |<\/p>\n

Customize | Tools\u201d.<\/p>\n

<\/a><\/a>1.4.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>OLE\/COM Object Viewer<\/span><\/h2>\n

OLE\/COM Object Viewer goes through System Registry and<\/p>\n

collects all info about each coclass and their interfaces, and put them under<\/p>\n

one entry as their \u201cuser names\u201d, which is the help string in the IDL file. You<\/p>\n

can find this entry under \u201cAll Objects\u201d entry.<\/p>\n

The \u201cuser name\u201d entry stores the info about the coclass<\/p>\n

itself. Under it there are entries for all the interfaces of this class. Each<\/p>\n

entry stores the info about a specific interface.<\/p>\n

OLD\/COM Object Viewer can be started both from the \u201cStart\u201d<\/p>\n

menu and from Visual C++ menu \u201cTools\u201d.<\/p>\n

<\/a><\/a>1.5.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>System Registry<\/span><\/h2>\n

System Registry contains information about the computer.<\/p>\n

Under its \u201cHKEY_CLASSES_ROOT<\/strong>\u201d entry, all information about a coclass is<\/p>\n

stored. Under this entry, all coclasses are listed by their ProgID<\/strong>s.<\/p>\n

Among the countless ProgID entries, there are two other entries: one named CLSID<\/strong>,<\/p>\n

under which all coclasses are listed by their guids; the other named Interface<\/strong>,<\/p>\n

under which all interfaces are listed by their guids.<\/p>\n

ProgIDs<\/strong> are not guaranteed to be unique. They are<\/p>\n

used by some languages that can not directly refer to guids such as VBScript.<\/p>\n

VB can directly refer to guids, and can also optionally use ProgIDs. COM<\/p>\n

library provides to functions which can go through the System Registry and<\/p>\n

convert a ProgID to a CLSID or vice versa:<\/p>\n

\u00a0<\/span><\/p>\n

CLSID clsid;<\/span><\/p>\n

CLSIDFromProgID<\/span><\/strong>(L”Cars.Jeep.1″, &clsid);<\/span><\/p>\n

\u00a0<\/span><\/p>\n

LPOLESTR progid;<\/span><\/p>\n

ProgIDFromCLSID<\/span><\/strong>(clsid, &progid);<\/span><\/p>\n

We also need an entry to store some attributes about the<\/p>\n

whole server. For each server we can assign an AppID<\/strong>, under which we<\/p>\n

store all those atttributes such as AccessPermission<\/strong>, AuthenticationLevel<\/strong>,<\/p>\n

DllSurogate<\/strong>, LunchPermissions<\/strong>, RemoteServerName<\/strong>, etc. Then<\/p>\n

under each coclass entry under HKCR\\CLSID, we add an AppID entry containing the<\/p>\n

AppID of the server.<\/p>\n

When a coclass in invoked, the SCM reads the CLSID entry<\/p>\n

under HKCR\\CLSID. If it finds an AppID entry, it will go further to find the<\/p>\n

AppID entry under HKCR\\AppID. There it reads more about the server and knows<\/p>\n

how to deal with the server. For example, if SCM finds RemoteServerName<\/strong><\/p>\n

entry there containing the name of another computer, it knows that the server<\/p>\n

is located oin another computer and it should contact the SCM of that computer.<\/p>\n

When you call COM library functions such as CoCreateInstance<\/strong><\/p>\n

passing a guid constant such as “CLSID_CoCar” or<\/p>\n

“IID_IRegistration”, the compiler converts the guid contstant to the<\/p>\n

real guid by looking up the guid definition file *_i.c<\/strong>. At run time the<\/p>\n

real guid is sent to the API function.<\/p>\n

\u00a8\u00a0\u00a0\u00a0 <\/span><\/span><\/span>DLL<\/h3>\n

server’s entries in System Registry<\/p>\n

A DLL server should have the following basic entries in the<\/p>\n

System Registry:<\/p>\n

\u00a0<\/span><\/p>\n

HKEY_CLASSES_ROOT\\<ProgID><\/span><\/strong>\\CLSID<\/span><\/p>\n

= <clsid><\/p>\n

HKEY_CLASSES_ROOT\\CLSID\\<clsid><\/span><\/strong> = <ProgID><\/span><\/p>\n

HKEY_CLASSES_ROOT\\CLSID\\<clsid>\\InprocServer32<\/span><\/strong> = <server full path><\/span><\/p>\n

You do not have to register your type library, for VC can<\/p>\n

directly #import from any directory, and VB and J++ can browse to find a *.tlb<\/p>\n

file. However, if you want to do it, you should add the following type library<\/p>\n

entries:<\/p>\n

\u00a0<\/span><\/p>\n

HKEY_CLASSES_ROOT\\CLSID\\<clsid>\\TypeLib<\/span><\/p>\n

= <libid><\/p>\n

HKEY_CLASSES_ROOT\\TypeLib\\<libid> =<\/span><\/p>\n

<type library help string><\/p>\n

HKEY_CLASSES_ROOT\\TypeLib\\<libid>\\1.0\\0\\Win32<\/span><\/p>\n

= <type library full path><\/p>\n

HKEY_CLASSES_ROOT\\TypeLib\\<libid>\\1.0\\FLAGS<\/span><\/p>\n

= 0<\/p>\n

HKEY_CLASSES_ROOT\\TypeLib\\<libid>\\1.0\\HELPDIR<\/span><\/p>\n

When client calls CoCreateInstance<\/strong> with a CLSID and a<\/p>\n

IID, the COM run time will:<\/p>\n

1.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/p>\n

go to the HKCR\\CLSID\\<guid>\\InProcServer32<\/strong><\/p>\n

entry to find the location of the DLL server.<\/p>\n

2.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/p>\n

load the DLL into process, call its exported DllGetClassObject<\/strong><\/p>\n

function passing the coclass guid to get an IClassFactory<\/strong> pointer of the<\/p>\n

corresponding class factory;<\/p>\n

3.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/p>\n

call the IClassFactory<\/strong>‘s CreateInstance<\/strong><\/p>\n

method passing the IID of the interface to get a pointer of the interface.<\/p>\n

You can see in the above process that the guids of the<\/p>\n

interfaces are only used inside the class factory. There is no need to store an<\/p>\n

entry for an interface in the System Registry.<\/p>\n

\u00a8\u00a0\u00a0\u00a0 <\/span><\/span><\/span>EXE<\/h3>\n

server’s entries in System Registry<\/p>\n

A EXE server should have similar basic entries as a DLL<\/p>\n

server except it is LocalServer32<\/strong>:<\/p>\n

\u00a0<\/span><\/p>\n

HKEY_CLASSES_ROOT\\<ProgID><\/span><\/strong>\\CLSID<\/span><\/p>\n

= <clsid><\/p>\n

HKEY_CLASSES_ROOT\\CLSID\\<clsid><\/span><\/strong> = <ProgID><\/span><\/p>\n

HKEY_CLASSES_ROOT\\CLSID\\<clsid>\\LocalServer32<\/span><\/strong> = <server full path><\/span><\/p>\n

Besides these, it should have the following entries for each<\/p>\n

interface:<\/p>\n

\u00a0<\/span><\/p>\n

HKEY_CLASSES_ROOT\\Interface\\<iid><\/span><\/p>\n

HKEY_CLASSES_ROOT\\Interface\\ProxyStubClsid =<\/span><\/p>\n

<proxy\/stub dll clsid><\/p>\n

HKEY_CLASSES_ROOT\\Interface\\ProxyStubClsid32<\/span><\/p>\n

= <proxy\/stub dll clsid><\/p>\n

If you use universal marshaller oleaut32.dll<\/strong>, which<\/p>\n

reads the registered type library and creates proxy\/stub classes on the fly,<\/p>\n

you should put the CLSID of oleaut32.dll<\/strong> under ProxyStubClsid32<\/strong>, add<\/p>\n

the following interface entry, plus all the type library entries:<\/p>\n

\u00a0<\/span><\/p>\n

HKEY_CLASSES_ROOT\\Interface\\TypeLib =<\/span><\/p>\n

<type library libid><\/p>\n

For each interface you invoke, one proxy\/stub object is<\/p>\n

instantiated. Therefore, you must set up a correspondence between an interface<\/p>\n

and its proxy\/stub DLL server, so that when client invoke an interface, the SCM<\/p>\n

can find the corresponding proxy\/stub DLL and create the corresponding<\/p>\n

proxy\/stub object from it.<\/p>\n

For this purpose, the System Registry stores the guids of<\/p>\n

the all interfaces of an EXE server under entry HKCR\\Interface<\/strong>. Under<\/p>\n

each interface guid entry there is a ProxyStubClsid32<\/strong> entry, which<\/p>\n

stores the CLSID<\/strong> of the custom proxy\/stub DLL server which contains the<\/p>\n

proxy\/stub coclass for that interface, or the universal marshaller oleaut32.dll<\/strong>.<\/p>\n

Therefore, if you use the type library marshalling, you must<\/p>\n

register the type library under HKCR\\TypeLib<\/strong> entry and each interface<\/p>\n

entry.<\/p>\n

System Registry editor can be started at command line by<\/p>\n

typing \u201cregedit\u201d, or from OLE\/COM Object Viewer in Visual C++.<\/p>\n

<\/a><\/a>2.\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h1>\n

 <\/p>\n

<\/a>Unicode Handling<\/span><\/h1>\n

<\/a><\/a><\/a>2.1.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>Definitions of Different Type of Strings<\/span><\/span><\/h2>\n

\u00a8\u00a0\u00a0\u00a0 <\/span><\/span><\/span>wchar_t<\/h3>\n

In C++ wchar_t is 16-bit wide character represented by unsigned<\/strong><\/p>\n

short:<\/p>\n

\u00a0<\/span><\/p>\n

typedef wchar_t WCHAR;\/\/ wc,<\/span><\/p>\n

16-bit UNICODE character<\/p>\n

typedef unsigned short wchar_t;<\/span><\/p>\n

\u00a8\u00a0\u00a0\u00a0 <\/span><\/span><\/span>LPOLESTR<\/h3>\n

In C++ LPOLESTR is a 16-bit unicode string represented by<\/p>\n

const unsigned short *<\/strong>:<\/p>\n

\u00a0<\/span><\/p>\n

typedef OLECHAR __RPC_FAR * LPOLESTR;<\/span><\/p>\n

typedef WCHAR OLECHAR;<\/span><\/p>\n

\u00a8\u00a0\u00a0\u00a0 <\/span><\/span><\/span>LPCOLESTR<\/h3>\n

In C++ LPOLESTR is a constant 16-bit unicode string<\/p>\n

represented by const<\/strong> unsigned short *<\/strong>:<\/p>\n

\u00a0<\/span><\/p>\n

typedef const OLECHAR __RPC_FAR *LPCOLESTR;<\/span><\/p>\n

\u00a8\u00a0\u00a0\u00a0 <\/span><\/span><\/span>LPSTR<\/h3>\n

In C++ LPSTR is 8-bit multi-byte\/ANSI string represented by<\/strong><\/p>\n

char *<\/p>\n

\u00a0<\/span><\/p>\n

typedef CHAR *LPSTR, *PSTR;<\/span><\/p>\n

typedef char CHAR;<\/span><\/p>\n

\u00a8\u00a0\u00a0\u00a0 <\/span><\/span><\/span>LPCSTR<\/h3>\n

In C++ LPCSTR is 8-bit multi-byte\/ANSI string represented by<\/strong><\/p>\n

const char *:<\/p>\n

\u00a0<\/span><\/p>\n

typedef CONST CHAR *LPCSTR, *PCSTR;<\/span><\/p>\n

\u00a8\u00a0\u00a0\u00a0 <\/span><\/span><\/span>TCHAR<\/h3>\n

In C++ TCHAR is 8-bit character represented by char<\/strong>:<\/p>\n

\u00a0<\/span><\/p>\n

typedef char TCHAR, *PTCHAR;<\/span><\/p>\n

<\/a><\/a><\/a><\/a>2.2.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>CString <=> Multibyte String<\/span><\/span><\/span><\/h2>\n

\u00a0<\/span><\/span><\/span><\/p>\n

#define m(x) ::MessageBox(NULL, x,<\/span><\/span><\/span><\/p>\n

“Test”, MB_OK | MB_TOPMOST)<\/p>\n

\u00a0<\/span><\/span><\/span><\/p>\n

CString cstr(“Hello the world”);<\/p>\n

\u00a0<\/span><\/span><\/span><\/p>\n

\/\/ CString::GetBuffer returns a pointer to<\/span><\/span><\/span><\/p>\n

its underlying buffer.<\/p>\n

LPSTR<\/span><\/span><\/span><\/p>\n

lpsz = cstr.GetBuffer(cstr.GetLength());<\/p>\n

\u00a0<\/span><\/span><\/span><\/p>\n

\/\/ Both lpsz and cstr can access the<\/span><\/span><\/span><\/p>\n

underlying buffer.<\/p>\n

m(lpsz);<\/p>\n

m(cstr);<\/p>\n

\u00a0<\/span><\/span><\/span><\/p>\n

\/\/ You can amend the buffer through cstr.<\/span><\/span><\/span><\/p>\n

cstr<\/span><\/span><\/span><\/p>\n

= “Hi Frank.”;<\/p>\n

m(lpsz);<\/p>\n

\u00a0<\/span><\/span><\/span><\/p>\n

\/\/ You can also amend the buffer through<\/span><\/span><\/span><\/p>\n

lpsz, but you can’t free it.<\/p>\n

lpsz[8] = ‘!’;<\/p>\n

m(cstr);<\/p>\n

\/\/<\/span><\/span><\/span><\/p>\n

free(lpsz); \/\/ Not allowed! Will cause run-time<\/span><\/p>\n

error!<\/p>\n

\u00a0<\/span><\/span><\/span><\/p>\n

\/\/ After releasing the buffer, lpsz’s content<\/span><\/span><\/span><\/p>\n

becomes undefined<\/p>\n

cstr.ReleaseBuffer();<\/p>\n

m(cstr);<\/p>\n

\u00a0<\/span><\/span><\/span><\/p>\n

\/\/ If you want to avoid amending the<\/span><\/span><\/span><\/p>\n

original content of the CString,<\/p>\n

\/\/ make a copy.<\/span><\/span><\/span><\/p>\n

LPSTR<\/span><\/span><\/span><\/p>\n

lpszCopy = (LPSTR)malloc(strlen(lpsz));<\/p>\n

memset(lpszCopy, 0, strlen(lpsz) + 1);<\/p>\n

strcpy(lpszCopy, lpsz);<\/span><\/span><\/span><\/p>\n

m(lpszCopy);<\/p>\n

<\/a><\/a>2.3.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>CString <=> Wide Character String<\/span><\/span><\/span><\/h2>\n

\u00a0<\/span><\/span><\/span><\/p>\n

void CICPLoginDlg::CStringToWideChar(CString<\/span><\/span><\/span><\/p>\n

cstr, wchar_t * pwchar, int size)<\/p>\n

{<\/span><\/span><\/span><\/p>\n

int<\/span><\/span><\/span><\/p>\n

cstrLen = cstr.GetLength();<\/p>\n

ASSERT(cstrLen < MAX_LENGTH);<\/p>\n

MultiByteToWideChar<\/span><\/strong>(CP_ACP, MB_PRECOMPOSED,<\/span><\/span><\/span><\/p>\n

cstr.GetBuffer(cstrLen),<\/p>\n

cstrLen, pwchar, size);<\/p>\n

cstr.ReleaseBuffer();<\/p>\n

}<\/span><\/span><\/span><\/p>\n

 <\/p>\n

<\/a><\/a>2.4.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>Allocating and Freeing BSTRs with API Functions<\/span><\/span><\/h2>\n

BSTR stands for basic string. It is a 16-bit Unicode with a<\/p>\n

prefix telling the count of the bytes in this string, therefore do not need<\/p>\n

NULL at the end.<\/p>\n

When a server creates and passes out a BSTR, the server<\/p>\n

allocates memory space for the BSTR, while the client should deallocate the<\/p>\n

memory with a call to API function SysFreeString<\/strong>.<\/p>\n

\u00a8\u00a0\u00a0\u00a0 <\/span><\/span><\/span>Creating<\/h3>\n

a new BSTR<\/p>\n

\u00a0<\/span><\/p>\n

BSTR bstr1 = SysAllocString<\/span><\/strong>(L<\/span><\/strong>“Hello world!”);<\/span><\/p>\n

OLECHAR<\/span><\/strong> * pOleStr = OLESTR(“Good morning!”);<\/span><\/p>\n

BSTR bstr2 = SysAllocString<\/span><\/strong>(pOleStr);<\/span><\/p>\n

\u00a8\u00a0\u00a0\u00a0 <\/span><\/span><\/span>Modifying<\/h3>\n

a BSTR<\/p>\n

\u00a0<\/span><\/p>\n

SysReAllocString<\/span><\/strong>(&bstr1, L<\/span><\/strong>“Good<\/span><\/p>\n

morning!”);<\/p>\n

\u00a8\u00a0\u00a0\u00a0 <\/span><\/span><\/span>Freeing<\/h3>\n

a BSTR<\/p>\n

\u00a0<\/span><\/p>\n

SysFreeString<\/span><\/strong>(bstr1);<\/span><\/p>\n

<\/a><\/a><\/a>2.5.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>BSTR <=> CString<\/span><\/span><\/h2>\n

\u00a0<\/span><\/p>\n

CString cstr(\u201cHello!\u201d);<\/span><\/p>\n

BSTR bstr = cstr.AllocSysString<\/span><\/strong>();<\/span><\/p>\n

\u00a0<\/span><\/p>\n

BSTR bstr = SysAllocString(L”Hello<\/span><\/p>\n

Frank!”);<\/p>\n

CString cstr(bstr);<\/span><\/p>\n

<\/a><\/a><\/a>2.6.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>BSTR <=> Multibyte String<\/span><\/span><\/h2>\n

Second, use function wcstombs<\/strong> (wide character string<\/p>\n

to multibyte string) and mbstowcs<\/strong> (multibyte string to wide character<\/p>\n

string):<\/p>\n

\u00a0<\/span><\/p>\n

BSTR bstr1 = SysAllocString(L”Hellow<\/span><\/p>\n

world!”);<\/p>\n

char * buf[80];<\/span><\/p>\n

wcstombs<\/span><\/strong>(buf, bstr1, 80);<\/span><\/p>\n

SysFreeString(bstr1);<\/span><\/p>\n

\u00a0<\/span><\/p>\n

sprintf(buf, “Good morning!”);<\/span><\/p>\n

BSTR bstr2;<\/span><\/p>\n

mbstowcs<\/span><\/strong>(bstr2, buf, 80);<\/span><\/p>\n

<\/a><\/a><\/a>2.7.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>Multibyte String <=> Wide Character String<\/span><\/span><\/h2>\n

\u00a0<\/span><\/span><\/p>\n

char<\/span><\/span><\/p>\n

* mbstr = “Hello world!”;<\/p>\n

int<\/span><\/span><\/p>\n

len1 = strlen<\/span><\/strong>(mbstr);<\/p>\n

\u00a0<\/span><\/span><\/p>\n

wchar_t<\/span><\/span><\/p>\n

wcbuf[80];<\/p>\n

int<\/span><\/span><\/p>\n

len2 = sizeof<\/span><\/strong>(wcbuf) \/ sizeof<\/span><\/strong>(wchar_t);<\/p>\n

::memset<\/span><\/strong>(wcbuf, 0,<\/span><\/span><\/p>\n

sizeof(wcbuf));<\/p>\n

\u00a0<\/span><\/span><\/p>\n

<\/a>MultiByteToWideChar<\/span><\/strong>(<\/span><\/span><\/p>\n

CP_ACP, <\/span><\/span><\/p>\n

MB_PRECOMPOSED, <\/span><\/span><\/p>\n

mbstr, <\/span><\/span><\/p>\n

len1, <\/span><\/span><\/p>\n

wcbuf, <\/span><\/span><\/p>\n

len2);<\/span><\/span><\/p>\n

\u00a0<\/span><\/span><\/p>\n

char<\/span><\/span><\/p>\n

buf[300];<\/p>\n

sprintf(buf,<\/span><\/span><\/p>\n

“wcbuf = %S”, wcbuf);<\/p>\n

::MessageBox(NULL,<\/span><\/span><\/p>\n

buf, NULL, MB_OK);<\/p>\n

\u00a0<\/span><\/span><\/p>\n

\u00a0<\/span><\/span><\/p>\n

wchar_t<\/span><\/span><\/p>\n

* wcstr = L”Hello world!”;<\/p>\n

int<\/span><\/span><\/p>\n

len3 = wcslen<\/span><\/strong>(wcstr);<\/p>\n

\u00a0<\/span><\/span><\/p>\n

char<\/span><\/span><\/p>\n

mbbuf[300];<\/p>\n

int<\/span><\/span><\/p>\n

len4 = sizeof<\/span><\/strong>(mbbuf);<\/p>\n

::memset<\/span><\/strong>(mbbuf, 0, len4);<\/span><\/span><\/p>\n

\u00a0<\/span><\/span><\/p>\n

<\/a>WideCharToMultiByte<\/span><\/strong>(<\/span><\/span><\/p>\n

CP_ACP, <\/span><\/span><\/p>\n

WC_COMPOSITECHECK, <\/span><\/span><\/p>\n

wcstr, <\/span><\/span><\/p>\n

len3, <\/span><\/span><\/p>\n

mbbuf, <\/span><\/span><\/p>\n

len4, <\/span><\/span><\/p>\n

NULL, <\/span><\/span><\/p>\n

NULL);<\/span><\/span><\/p>\n

\u00a0<\/span><\/span><\/p>\n

::MessageBox(NULL,<\/span><\/span><\/p>\n

mbbuf, NULL, MB_OK);<\/p>\n

<\/a><\/a>2.8.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>Converting with ATL Macros<\/span><\/span><\/h2>\n

ATL provides a group of macros to convert between different<\/p>\n

types. Because one convertion involves a series of temporary variables to hold<\/p>\n

and swap the string buffers, the space is prepared by macro USES_CONVERSION<\/strong>,<\/p>\n

which should be called before any conversion. They are defined in <atlconv.h><\/strong>.<\/p>\n\n\n\n\n\n\n\n\n\n\n
\n

ANSI to …<\/strong><\/p>\n<\/td>\n

\n

OLE to …<\/strong><\/p>\n<\/td>\n

\n

TCHAR to …<\/strong><\/p>\n<\/td>\n

\n

wchar_t to …<\/strong><\/p>\n<\/td>\n<\/tr>\n

\n

A2BSTR<\/p>\n<\/td>\n

\n

OLE2A<\/p>\n<\/td>\n

\n

T2A<\/p>\n<\/td>\n

\n

W2A<\/p>\n<\/td>\n<\/tr>\n

\n

A2COLE<\/p>\n<\/td>\n

\n

OLE2BSTR<\/p>\n<\/td>\n

\n

T2BSTR<\/p>\n<\/td>\n

\n

W2BSTR<\/p>\n<\/td>\n<\/tr>\n

\n

A2CT<\/p>\n<\/td>\n

\n

OLE2CA<\/p>\n<\/td>\n

\n

T2CA<\/p>\n<\/td>\n

\n

W2CA<\/p>\n<\/td>\n<\/tr>\n

\n

A2CW<\/p>\n<\/td>\n

\n

OLE2CT<\/p>\n<\/td>\n

\n

T2COLE<\/p>\n<\/td>\n

\n

W2COLE<\/p>\n<\/td>\n<\/tr>\n

\n

A2OLE<\/p>\n<\/td>\n

\n

OLE2CW<\/p>\n<\/td>\n

\n

T2CW<\/p>\n<\/td>\n

\n

W2CT<\/p>\n<\/td>\n<\/tr>\n

\n

A2T<\/p>\n<\/td>\n

\n

OLE2T<\/p>\n<\/td>\n

\n

T2OLE<\/p>\n<\/td>\n

\n

W2OLE<\/p>\n<\/td>\n<\/tr>\n

\n

A2W<\/p>\n<\/td>\n

\n

OLE2W<\/p>\n<\/td>\n

\n

T2W<\/p>\n<\/td>\n

\n

W2T<\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

\u00a0<\/span><\/p>\n

<\/a>USES_CONVERSION;<\/span><\/p>\n

MessageBox(NULL, W2A<\/span><\/strong>(bstr),<\/span><\/p>\n

NULL, MB_OK);<\/p>\n

<\/a><\/a><\/a>2.9.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>MFC’s BSTR Helper Class _bstr_t<\/span><\/span><\/h2>\n

MFC provides class _bstr_t<\/strong> to wrap BSTR. _bstr_t<\/strong>‘s<\/p>\n

constructor can take many types as input:<\/p>\n

\u00a0<\/span><\/p>\n

_bstr_t( ) throw( );<\/span><\/p>\n

_bstr_t( const<\/strong><\/span><\/p>\n

_bstr_t &s1 ) throw( );<\/p>\n

_bstr_t( const<\/strong><\/span><\/p>\n

char *s2 ) throw( _com_error );<\/p>\n

_bstr_t( const<\/strong><\/span><\/p>\n

wchar_t *s3 ) throw( _com_error );<\/p>\n

_bstr_t( const<\/strong><\/span><\/p>\n

_variant_t &var ) throw ( _com_error );<\/p>\n

_bstr_t( BSTR<\/span><\/strong><\/span><\/p>\n

bstr, bool<\/span><\/strong> fCopy ) throw ( _com_error );<\/p>\n

Its assignment operator = is also overloaded for many types:<\/p>\n

\u00a0<\/span><\/p>\n

_bstr_t& operator=( const _bstr_t &<\/span><\/strong> s1 ) throw ( );<\/span><\/p>\n

_bstr_t& operator=( const char *<\/span><\/strong> s2 ) throw( _com_error );<\/span><\/p>\n

_bstr_t& operator=( const wchar_t *<\/span><\/strong> s3 ) throw( _com_error );<\/span><\/p>\n

_bstr_t& operator=( const _variant_t &<\/span><\/strong> var ) throw( _com_error );<\/span><\/p>\n

It has also overloaded +=, +, ! and all comparison<\/p>\n

operators.<\/p>\n

To get a LPTSTR<\/strong> from _bstr_t<\/strong>:<\/p>\n

\u00a0<\/span><\/p>\n

_bstr_t<\/span><\/p>\n

bstrt(“Hello!”);<\/p>\n

LPTSTR<\/span><\/p>\n

lp1 = (LPTSTR)<\/span><\/strong>bstrt;<\/p>\n

LPTSTR<\/span><\/p>\n

lp2 = bstrt.operator char *()<\/span><\/strong>;<\/p>\n

You can use _bstr_t<\/strong> anywhere expecting BSTR. If you like,<\/p>\n

you can also explicitly cast _bstr_t<\/strong> to BSTR<\/strong>:<\/p>\n

\u00a0<\/span><\/p>\n

_bstr_t bstrt(“Hello!”);<\/span><\/p>\n

BSTR bstr = (BSTR)<\/span><\/strong>bstrt;<\/span><\/p>\n

SysFreeString(bstr1);<\/span><\/p>\n

_bstr_t<\/strong> object does not need to be deallocated. It is<\/p>\n

deallocated automatically when it leaves scope.<\/p>\n

Class _bstr_t<\/strong> is contained in header file <comdef.h<\/strong>>.<\/p>\n

<\/a><\/a><\/a>2.10.\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>ATL’s BSTR Helper Class CComBSTR<\/span><\/span><\/h2>\n

ATL also provides a wrapper class CComBSTR<\/strong>, which is<\/p>\n

more light than _bstr_t<\/strong>. CComBSTR wraps a BSTR data member m_str<\/strong>.<\/p>\n

Space for BSTR<\/strong> is allocated in its constructor and deallocated in the<\/p>\n

destructor.<\/p>\n

Its constructor can take LPCOLESTR<\/strong> or LPCSTR<\/strong><\/p>\n

as input. It can also designate the size of the buffer.<\/p>\n

\u00a0<\/span><\/p>\n

CComBSTR( int nSize );<\/span><\/p>\n

CComBSTR( int nSize, LPCOLESTR<\/span><\/strong> sz );<\/span><\/p>\n

CComBSTR( int nSize, LPCSTR<\/span><\/strong> sz );<\/span><\/p>\n

CComBSTR( LPCOLESTR<\/span><\/strong><\/span><\/p>\n

pSrc );<\/p>\n

CComBSTR( LPCSTR<\/span><\/strong><\/span><\/p>\n

pSrc );<\/p>\n

CComBSTR( const CComBSTR& src );<\/span><\/p>\n

Therefore you can say:<\/p>\n

\u00a0<\/span><\/strong><\/p>\n

CComBSTR comBstr(\u201cHello!\u201d);<\/span><\/p>\n

To detach m_str<\/strong> from CComBSTR<\/strong>:<\/p>\n

\u00a0<\/span><\/p>\n

BSTR bstr = comBstr.Detach<\/span><\/strong>();<\/span><\/p>\n

To attach a BSTR<\/strong> to a CComBSTR<\/strong>:<\/p>\n

\u00a0<\/span><\/p>\n

BSTR bstr =<\/span><\/p>\n

SysAllocString(L”Hello!”);<\/p>\n

CComBSTR comBstr;<\/span><\/p>\n

comBstr.Attach<\/span><\/strong>(bstr);<\/span><\/p>\n

To get a copy of m_str<\/strong>:<\/p>\n

\u00a0<\/span><\/p>\n

BSTR bstr = comBstr.Copy<\/span><\/strong>();<\/span><\/p>\n

To get the address of m_str<\/strong>:<\/p>\n

\u00a0<\/span><\/p>\n

BSTR * pBstr = &comBstr.<\/span><\/p>\n

To free m_str<\/strong>:<\/p>\n

\u00a0<\/span><\/p>\n

comBstr.Empty<\/span><\/strong>();<\/span><\/p>\n

The overloaded assignment operator takes LPCOLESTR<\/strong> or<\/p>\n

LPCSTR<\/strong> as parameter. Therefore, to change the value of CComBSTR<\/strong>:<\/p>\n

\u00a0<\/span><\/p>\n

CComBSTR comBstr();<\/span><\/p>\n

comBstr = L”Good morning!”;<\/span><\/p>\n

CComBSTR<\/strong> can only be casted to CString, which can be<\/p>\n

than casted to LPCSTR<\/strong> or LPCTSTR<\/strong>:<\/p>\n

\u00a0<\/span><\/p>\n

cstr = (CString)comBstr;<\/span><\/p>\n

CComBSTR<\/strong> is contained in header file <atlbase.h<\/strong>>,<\/p>\n

which also contains other wrapper classes.<\/p>\n

<\/a><\/a><\/a>3.\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/span><\/h1>\n

 <\/p>\n

DLL and EXE Server Without ATL<\/span><\/span><\/h1>\n

<\/a><\/a>3.1.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>Creating a DLL Server in Purely C++ Code<\/span><\/h2>\n

\u00a8\u00a0\u00a0\u00a0 <\/span><\/span><\/span>Step<\/h3>\n

1:create a housing for your DLL<\/p>\n

Create a new source file with the name of the project, say<\/p>\n

CarDll.cpp, with two global variables:<\/p>\n

\u00a0<\/span><\/p>\n

\/\/************* CarDll.cpp *******************<\/span><\/p>\n

#include <windows.h><\/span><\/p>\n

\u00a0<\/span><\/p>\n

ULONG g_lockCount<\/span><\/strong><\/span><\/p>\n

= 0;<\/p>\n

ULONG g_objCount<\/span><\/strong><\/span><\/p>\n

= 0;<\/p>\n

These two global variables are used for life time control of<\/p>\n

the DLL server (explained later). The <windows.h<\/strong>> header file is<\/p>\n

the one essential include file required in all Windows source code. It contains<\/p>\n

all of the definitions for Windows messages, constants, flag values, data<\/p>\n

structures, macros, and other mnemonics that permit the programmer to work<\/p>\n

without having to memorize thousands of hexadecimal values and their functions.<\/p>\n

\u00a8\u00a0\u00a0\u00a0 <\/span><\/span><\/span>Step<\/h3>\n

2:define your interfaces<\/p>\n

Create a header file in any name in an empty DLL project<\/p>\n

workspace, say “interface.h”, and define your interfaces in it:<\/p>\n

\u00a0<\/span><\/p>\n

\/\/*************** interface.h<\/span><\/p>\n

***********************<\/p>\n

#ifndef _INTERFACES<\/span><\/p>\n

#define _INTERFACES<\/span><\/p>\n

\u00a0<\/span><\/p>\n

#include <unknwn.h> \/\/ Needed if<\/span><\/p>\n

WIN32_LEAN_AND_MEAN is defined in stdafx.h<\/p>\n

#include <windows.h><\/span><\/p>\n

\u00a0<\/span><\/p>\n

struct IRegistration : public IUnknown<\/span><\/p>\n

{<\/span><\/p>\n

virtual HRESULT __stdcall <\/span><\/strong>GetOwner(BSTR *<\/span><\/p>\n

pBstrOwner) = 0;<\/p>\n

virtual HRESULT __stdcall SetOwner(BSTR bstrOwner) = 0;<\/p>\n

};<\/span><\/p>\n

\u00a0<\/span><\/p>\n

struct IStatus : public IUnknown<\/span><\/p>\n

{<\/span><\/p>\n

virtual HRESULT __stdcall GetSpeed)(int * pnSpeed) = 0;<\/p>\n

virtual HRESULT __stdcall SetSpeed)(int nSpeed) = 0;<\/p>\n

};<\/span><\/p>\n

\u00a0<\/span><\/p>\n

#endif<\/span><\/p>\n

Calling convention __stdcall<\/strong> defines the way function<\/p>\n

call arguments are pushed into stack, poped out, and name-decorating convention<\/p>\n

that the compiler uses to identify individual functions.<\/p>\n

\u00a8\u00a0\u00a0\u00a0 <\/span><\/span><\/span>Step<\/h3>\n

3:define guids for interfaces<\/p>\n

Create a new header file in any name, say iid.h. Use guid<\/p>\n

generator guidgen.exe<\/strong> to directly generate new guids in correct format<\/p>\n

for all new interfaces, and assign a constant alias for each guid:<\/p>\n

\u00a0<\/span><\/p>\n

\/\/**************** iid.h<\/span><\/p>\n

*********************<\/p>\n

\/\/ {D427CA52-AF28-40a4-A5C2-97EA029DCD0F}<\/span><\/p>\n

DEFINE_GUID(IID_IRegistration<\/span><\/strong>,<\/span><\/p>\n

 <\/p>\n

0xd427ca52, 0xaf28, 0x40a4, 0xa5, 0xc2, 0x97,<\/span><\/p>\n

0xea, 0x2, 0x9d, 0xcd, 0xf);<\/p>\n

\u00a0<\/span><\/p>\n

\/\/ {D518B0BF-3EE1-4976-9B6A-9F3443A2A186}<\/span><\/p>\n

DEFINE_GUID(IID_IStatus<\/span><\/strong>,<\/span><\/p>\n

 <\/p>\n

0xd518b0bf, 0x3ee1, 0x4976, 0x9b, 0x6a, 0x9f,<\/span><\/p>\n

0x34, 0x43, 0xa2, 0xa1, 0x86);<\/p>\n

\u00a0<\/span><\/p>\n

\/\/ {2F481E63-C189-4d99-A705-9F3F2DFB7145}<\/span><\/p>\n

DEFINE_GUID(CLSID_Car<\/span><\/strong>,<\/span><\/p>\n

 <\/p>\n

0x2f481e63, 0xc189, 0x4d99, 0xa7, 0x5, 0x9f,<\/span><\/p>\n

0x3f, 0x2d, 0xfb, 0x71, 0x45);<\/p>\n

Create a corresponding source file iid.cpp. Simply include<\/p>\n

the following lines in the file:<\/p>\n

\u00a0<\/span><\/p>\n

\/\/***************** iid.cpp<\/span><\/p>\n

*********************<\/p>\n

#include “stdafx.h” <\/span><\/p>\n

#include <windows.h><\/span><\/p>\n

#include <objbase.h> \/\/ Needed if<\/span><\/p>\n

WIN32_LEAN_AND_MEAN defined in stdafx.h<\/p>\n

#include <initguid.h> \/\/ contains<\/span><\/p>\n

definition of DEFINE_GUID<\/p>\n

#include “iid.h”<\/span><\/p>\n

Header file <initguid.h<\/strong>> should be included<\/p>\n

before “iid.h”. By putting the lines shown above into a cpp file and<\/p>\n

letting the client programming inserting this cpp file into his project, this<\/p>\n

precedence is guaranteed.<\/p>\n

Note that when a client invokes for an IID or CLSID from the<\/p>\n

COM run time, the program will first loop up the guid definition file (iid.h in<\/p>\n

this case) to acquire the actual guid. That is to say, it is “0xd427ca52,<\/strong><\/p>\n

0xaf28, 0x40a4, 0xa5, 0xc2, 0x97, 0xea, 0x2, 0x9d, 0xcd, 0xf” not<\/p>\n

“IID_IRegistration<\/strong>” which is passed to the COM run time to be<\/p>\n

used to search in the System Registry. This is how the guid helps to maintain<\/p>\n

the global uniquenss of a coclass or interface.<\/p>\n

\u00a8\u00a0\u00a0\u00a0 <\/span><\/span><\/span>Step<\/h3>\n

4:create the coclass which implements<\/p>\n

the interfaces<\/p>\n

\u00a0<\/span><\/p>\n

\/\/**************** Car.h<\/span><\/p>\n

**********************<\/p>\n

#include “interfaces.h”<\/span><\/p>\n

\u00a0<\/span><\/p>\n

class Car : public IRegistration<\/span><\/strong>, public IStatus<\/span><\/strong><\/span><\/p>\n

{<\/p>\n

public:<\/span><\/p>\n

Car();<\/p>\n

virtual ~Car();<\/p>\n

\u00a0<\/span><\/p>\n

STDMETHODIMP QueryInterface<\/span><\/strong>(REFIID<\/p>\n

riid, void ** ppAny);<\/p>\n

STDMETHODIMP_(ULONG) AddRef<\/span><\/strong>();<\/p>\n

STDMETHODIMP_(ULONG) Release<\/span><\/strong>();<\/p>\n

\u00a0<\/span><\/p>\n

STDMETHODIMP GetOwner(BSTR * pBstrOwner);<\/p>\n

STDMETHODIMP SetOwner(BSTR bstrOwner);<\/p>\n

\u00a0<\/span><\/p>\n

STDMETHODIMP GetSpeed(int * pnSpeed);<\/p>\n

STDMETHODIMP SetSpeed(int nSpeed);<\/p>\n

\u00a0<\/span><\/p>\n

private:<\/span><\/p>\n

<\/a>ULONG m_refCount<\/span><\/strong>;<\/span><\/p>\n

\u00a0<\/span><\/p>\n

char m_pcOwner[80];<\/p>\n

int<\/span><\/p>\n

m_nSpeed;<\/p>\n

};<\/span><\/p>\n

\u00a0<\/span><\/p>\n

\/\/****************** Car.cpp ************************<\/span><\/p>\n

#include “Car.h”<\/span><\/p>\n

#include “iid.h”<\/span><\/p>\n

\u00a0<\/span><\/p>\n

extern ULONG g_lockCount;<\/span><\/p>\n

extern ULONG g_objCount;<\/span><\/p>\n

\u00a0<\/span><\/p>\n

Car::Car()<\/span><\/p>\n

{<\/span><\/p>\n

m_refCount = 0<\/span><\/strong>;<\/span><\/p>\n

g_objCount++<\/span><\/strong>;<\/span><\/p>\n

::memset(m_pcOwner, 0, 80);<\/p>\n

}<\/span><\/p>\n

\u00a0<\/span><\/p>\n

Car::~Car()<\/span><\/p>\n

{<\/span><\/p>\n

g_objCount–<\/span><\/strong>;<\/span><\/p>\n

}<\/span><\/p>\n

\u00a0<\/span><\/p>\n

STDMETHODIMP_(ULONG) Car::AddRef<\/span><\/strong>()<\/span><\/p>\n

{<\/span><\/p>\n

return ++m_refCount;<\/p>\n

}<\/span><\/p>\n

\u00a0<\/span><\/p>\n

STDMETHODIMP_(ULONG) Car::Release<\/span><\/strong>()<\/span><\/p>\n

{<\/span><\/p>\n

if(–m_refCount == 0)<\/span><\/strong><\/span><\/p>\n

{<\/span><\/p>\n

delete this<\/span><\/strong>;<\/p>\n

return 0;<\/p>\n

}<\/span><\/p>\n

else<\/p>\n

return m_refCount;<\/p>\n

}<\/span><\/p>\n

\u00a0<\/span><\/p>\n

STDMETHODIMP Car::QueryInterface<\/span><\/strong>(REFIID<\/span><\/p>\n

riid, void ** ppAny)<\/p>\n

{<\/span><\/p>\n

\/\/<\/span><\/p>\n

IID_IUnknown is the REFIID of standard interface IUnknown<\/p>\n

if(riid == IID_IUnknown)<\/span><\/strong><\/span><\/p>\n

{<\/span><\/p>\n

\/\/ to avoid confusion caused by virtual inheritance<\/p>\n

*ppAny = (IUnknown *)(IStatus *)this;<\/p>\n

}<\/span><\/p>\n

else if(riid == IID_IRegistration)<\/span><\/strong><\/span><\/p>\n

{<\/span><\/p>\n

*ppAny = (IRegistration *)this;<\/p>\n

}<\/span><\/p>\n

else if(riid == IID_IStatus)<\/span><\/strong><\/span><\/p>\n

{<\/span><\/p>\n

*ppAny = (IStatus *)this;<\/p>\n

}<\/span><\/p>\n

else<\/p>\n

{<\/span><\/p>\n

*ppAny = NULL;<\/p>\n

return E_NOINTERFACE;<\/p>\n

}<\/span><\/p>\n

\u00a0<\/span><\/p>\n

((IUnknown *)(*ppAny))->AddRef();<\/p>\n

return<\/span><\/p>\n

S_OK;<\/p>\n

}<\/span><\/p>\n

\u00a0<\/span><\/p>\n

STDMETHODIMP Car::GetOwner(BSTR * pBstrOwner)<\/span><\/p>\n

{<\/span><\/p>\n

mbstowcs(*pBstrOwner, m_pcOwner, 80);<\/p>\n

return S_OK;<\/p>\n

}<\/span><\/p>\n

\u00a0<\/span><\/p>\n

STDMETHODIMP Car::SetOwner(BSTR bstrOwner)<\/span><\/p>\n

{<\/span><\/p>\n

wcstombs(m_pcOwner, bstrOwner, 80);<\/p>\n

return S_OK;<\/p>\n

}<\/span><\/p>\n

\u00a0<\/span><\/p>\n

STDMETHODIMP Car::GetSpeed(int * pnSpeed)<\/span><\/p>\n

{<\/span><\/p>\n

*pnSpeed = m_nSpeed;<\/p>\n

return S_OK;<\/p>\n

}<\/span><\/p>\n

\u00a0<\/span><\/p>\n

STDMETHODIMP Car::SetSpeed(int nSpeed)<\/span><\/p>\n

{<\/span><\/p>\n

m_nSpeed = nSpeed;<\/p>\n

return S_OK;<\/p>\n

}<\/span><\/p>\n

Macro STDMETHODIMP<\/strong> and STDMETHODIMP_(Type)<\/strong> are<\/p>\n

used to convert the function into __stdcall<\/strong> calling convention:<\/p>\n

\u00a0<\/span><\/p>\n

#define STDMETHODIMPHRESULT STDMETHODCALLTYPE<\/span><\/p>\n

#define STDMETHODIMP_(type)type STDMETHODCALLTYPE<\/span><\/p>\n

Pay attention the cascaded if structure in the QueryInterface<\/strong><\/p>\n

method. In iid.h, we stored some guids and assigned an alias for each of them.<\/p>\n

But actually nothing linked one guid\/ alias to one interface.Now here we find the link.<\/p>\n

\u00a8\u00a0\u00a0\u00a0 <\/span><\/span><\/span>Step<\/h3>\n

5:Create one class factory for each<\/p>\n

coclass<\/p>\n

In a separate header and source file, create a corresponding<\/p>\n

class factory class for each coclass. When its CreateInstance<\/strong> method is<\/p>\n

called, it simply create an instance of the corresponding coclass, and query<\/p>\n

its QueryInterface<\/strong> method for the passed REFIID.<\/p>\n

This is where a class factory is matched to its<\/p>\n

corresponding coclass.<\/p>\n

\u00a0<\/span><\/p>\n

\/\/***************** CarClassFactory.h<\/span><\/p>\n

***********************<\/p>\n

#ifndef _CARCLASSFACTORY<\/span><\/p>\n

#define _CARCLASSFACTORY<\/span><\/p>\n

\u00a0<\/span><\/p>\n

#include <windows.h><\/span><\/p>\n

\u00a0<\/span><\/p>\n

class CarClassFactory : public IClassFactory<\/span><\/strong> {<\/span><\/p>\n

public:<\/span><\/p>\n

CarClassFactory();<\/p>\n

virtual ~CarClassFactory();<\/span><\/p>\n

\u00a0<\/span><\/p>\n

HRESULT __stdcall QueryInterface(REFIID riid, void ** ppAny);<\/p>\n

ULONG __stdcall AddRef();<\/p>\n

ULONG __stdcall Release();<\/p>\n

\u00a0<\/span><\/p>\n

<\/a>HRESULT __stdcall CreateInstance<\/span><\/strong><\/span><\/p>\n

(LPUNKNOWN pUnkOuter, REFIID riid, void ** ppAny);<\/p>\n

HRESULT __stdcall LockServer<\/span><\/strong>(BOOL<\/span><\/p>\n

fLock);<\/p>\n

\u00a0<\/span><\/p>\n

private:<\/span><\/p>\n

ULONG m_refCount;<\/p>\n

};<\/span><\/p>\n

\u00a0<\/span><\/p>\n

#endif<\/span><\/p>\n

\u00a0<\/span><\/p>\n

\u00a0<\/span><\/p>\n

\/\/******************** CarClassFactory.cpp<\/span><\/p>\n

***********************<\/p>\n

#include “CarClassFactory.h”<\/span><\/p>\n

#include “car.h”<\/span><\/p>\n

\u00a0<\/span><\/p>\n

extern<\/span><\/strong> ULONG g_lockCount;<\/span><\/p>\n

extern<\/span><\/strong> ULONG g_objCount;<\/span><\/p>\n

\u00a0<\/span><\/p>\n

CarClassFactory::CarClassFactory()<\/span><\/p>\n

{<\/span><\/p>\n

m_refCount = 0<\/span><\/strong>;<\/span><\/p>\n

g_objCount++<\/span><\/strong>;<\/span><\/p>\n

}<\/span><\/p>\n

\u00a0<\/span><\/p>\n

CarClassFactory::~CarClassFactory()<\/span><\/p>\n

{<\/span><\/p>\n

g_objCount–<\/span><\/strong>;<\/span><\/p>\n

}<\/span><\/p>\n

\u00a0<\/span><\/p>\n

ULONG __stdcall<\/span><\/strong><\/span><\/p>\n

CarClassFactory::AddRef()<\/p>\n

{<\/span><\/p>\n

return ++m_refCount;<\/p>\n

}<\/span><\/p>\n

\u00a0<\/span><\/p>\n

ULONG __stdcall CarClassFactory::Release()<\/span><\/p>\n

{<\/span><\/p>\n

if(–m_refCount == 0)<\/span><\/p>\n

{<\/span><\/p>\n

delete this<\/span><\/strong>;<\/p>\n

return 0;<\/p>\n

}<\/span><\/p>\n

\u00a0<\/span><\/p>\n

return m_refCount;<\/p>\n

}<\/span><\/p>\n

\u00a0<\/span><\/p>\n

HRESULT __stdcall<\/span><\/strong><\/span><\/p>\n

CarClassFactory::QueryInterface(REFIID riid, void ** ppAny)<\/p>\n

{<\/span><\/p>\n

\/\/<\/span><\/p>\n

IID_IUnknown is the REFIID of standard interface IUnknown<\/p>\n

if(riid == IID_IUnknown)<\/p>\n

{<\/span><\/p>\n

*ppAny = (IUnknown *)this;<\/p>\n

}<\/span><\/p>\n

else if(riid == IID_IClassFactory)<\/p>\n

{<\/span><\/p>\n

*ppAny = (IClassFactory *)this;<\/p>\n

}<\/span><\/p>\n

else<\/p>\n

{<\/span><\/p>\n

*ppAny = NULL;<\/p>\n

return E_NOINTERFACE;<\/p>\n

}<\/span><\/p>\n

\u00a0<\/span><\/p>\n

((IUnknown *)(*ppAny))->AddRef();<\/p>\n

return S_OK;<\/p>\n

}<\/span><\/p>\n

\u00a0<\/span><\/p>\n

<\/a>HRESULT __stdcall<\/span><\/strong><\/span><\/p>\n

CarClassFactory::CreateInstance<\/span><\/strong><\/p>\n

(LPUNKNOWN pUnkOuter, REFIID riid, void ** ppAny)<\/p>\n

{<\/span><\/p>\n

if(pUnkOuter != NULL)<\/p>\n

{<\/span><\/p>\n

return CLASS_E_NOAGGREGATION;<\/p>\n

}<\/span><\/p>\n

\u00a0<\/span><\/p>\n

<\/a>Car * pCar = new Car()<\/span><\/strong>;<\/span><\/p>\n

<\/a>HRESULT hr = pCar->QueryInterface(riid, ppAny)<\/span><\/strong>;<\/span><\/p>\n

if(FAILED(hr)) delete pCar;<\/p>\n

return hr;<\/p>\n

}<\/span><\/p>\n

\u00a0<\/span><\/p>\n

HRESULT __stdcall<\/span><\/strong><\/span><\/p>\n

CarClassFactory::LockServer<\/span><\/strong>(BOOL fLock)<\/p>\n

{<\/span><\/p>\n

if(fLock)<\/p>\n

g_lockCount++<\/span><\/strong>;<\/span><\/p>\n

else<\/p>\n

g_lockCount–<\/span><\/strong>;<\/p>\n

\u00a0<\/span><\/p>\n

return S_OK;<\/p>\n

}<\/span><\/p>\n

Note that for this class factory class I did not use STDMETHOD<\/strong><\/p>\n

macros, instead I directly used __stdcall<\/strong>.<\/p>\n

\u00a8\u00a0\u00a0\u00a0 <\/span><\/span><\/span>Step<\/h3>\n

6:implement exported functions<\/p>\n

The mission of the exported function DllGetClassObject<\/strong><\/p>\n

is to hand to outside client the IClassFactory<\/strong> pointer which is implemented<\/p>\n

by the class factory. It takes the REFCLSID<\/strong> of a coclass, create an<\/p>\n

instance of its corresponding class factory and query its QueryInterface<\/strong><\/p>\n

for IClassFactory<\/strong> interface pointer.<\/p>\n

This is where the REFCLSID<\/strong> of the coclass is matched<\/p>\n

to its corresponding class factory.<\/p>\n

\u00a0<\/span><\/p>\n

#include “CarClassFactory.h”<\/span><\/p>\n

#include “iid.h”<\/span><\/p>\n

\u00a0<\/span><\/p>\n

ULONG g_lockCount = 0;<\/span><\/p>\n

ULONG g_objCount = 0;<\/span><\/p>\n

\u00a0<\/span><\/p>\n

STDAPI DllGetClassObject<\/span><\/strong>(REFCLSID<\/span><\/p>\n

rclsid, REFIID riid, void ** ppAny)<\/p>\n

{<\/span><\/p>\n

if(rclsid != CLSID_Car)<\/p>\n

return CLASS_E_CLASSNOTAVAILABLE;<\/p>\n

\u00a0<\/span><\/p>\n

<\/a>CarClassFactory * pFactory = new CarClassFactory<\/span><\/strong>;<\/span><\/p>\n

HRESULT hr = pFactory->QueryInterface<\/span><\/strong>(riid,<\/p>\n

ppAny);<\/p>\n

if(FAILED(hr))<\/p>\n

delete pFactory;<\/p>\n

\u00a0<\/span><\/p>\n

return hr;<\/p>\n

}<\/span><\/p>\n

\u00a0<\/span><\/p>\n

STDAPI DllCanUnloadNow<\/span><\/strong>()<\/span><\/p>\n

{<\/span><\/p>\n

if(g_lockCount == 0 && g_objCount == 0)<\/p>\n

return S_OK;<\/span><\/p>\n

else<\/p>\n

return S_FALSE;<\/p>\n

}<\/span><\/p>\n

\u00a8\u00a0\u00a0\u00a0 <\/span><\/span><\/span>Step<\/h3>\n

7:export the Dll functions<\/p>\n

Create a new def file (under source code) with the same name<\/p>\n

as the project workspace, which is CarDll.def<\/strong> to export the Dll<\/p>\n

functions:<\/p>\n

\u00a0<\/span><\/p>\n

“CarDll”<\/p>\n

<\/a>EXPORTS<\/span><\/strong><\/p>\n

DllGetClassObject@1<\/span><\/p>\n

PRIVATE<\/p>\n

DllCanUnloadNow@2<\/span><\/p>\n

PRIVATE<\/p>\n

\u00a8\u00a0\u00a0\u00a0 <\/span><\/span><\/span>Step<\/h3>\n

8:provide registration information<\/p>\n

Create a new reg file say CarDll.reg<\/strong> to merge<\/p>\n

the server information such as the GUIDs and the location into the System<\/p>\n

Registry:<\/p>\n

\u00a0<\/span><\/p>\n

HKEY_CLASSES_ROOT\\CarDll.Car\\CLSID =<\/span><\/p>\n

{2F481E63-C189-4d99-A705-9F3F2DFB7145}<\/p>\n

HKEY_CLASSES_ROOT\\CLSID\\{2F481E63-C189-4d99-A705-9F3F2DFB7145}<\/span><\/p>\n

= CarDll.Car<\/p>\n

HKEY_CLASSES_ROOT\\CLSID\\{2F481E63-C189-4d99-A705-9F3F2DFB7145}\\InprocServer32<\/span><\/p>\n

= D:\\My Documents\\Visual C++\\CarDLL\\debug\\CarDll.dll<\/p>\n

Note that each line is a “key = value”. There<\/p>\n

should be a space on each side of the equal sign, and no space (including tab)<\/p>\n

elsewhere.<\/p>\n

Double-click this reg file to merge the server information<\/p>\n

into the System Registry.<\/p>\n

<\/a><\/a>3.2.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>Life Time Control of a Coclass in a DLL Server<\/span><\/h2>\n

As we can see from the above example, a COM object is<\/p>\n

initiated by a client through the exported function DllGetClassObject<\/strong>,<\/p>\n

but is deleted by itself. This is the same with class factories in a DLL.<\/p>\n

Each coclass has a ULONG<\/strong> member m_refCount<\/strong>. In<\/p>\n

both the above raw C++ code and ATL\u2019s implementation, each time QueryInterface<\/strong><\/p>\n

successfully hands out an interface pointer, it increments the coclass<\/p>\n

reference count by calling AddRef<\/strong>. Therefore, after you acqure an<\/p>\n

interface pointer with CoCreateInstance<\/strong>, you do not need to call AddRef<\/strong>.<\/p>\n

However, after you make a copy of the interface pointer, you should call AddRef<\/strong>.<\/p>\n

A function receiving an interface pointer as parameter is also making copy of<\/p>\n

the pointer and thus should also call AddRef<\/strong>.<\/p>\n

Each time you (as a client or a function which receives an<\/p>\n

interface pointer as parameter) finishes using an interface, you should call<\/p>\n

its Release<\/strong> method. The coclass implementation of Release<\/strong> will<\/p>\n

decrement m_refCount<\/strong>, then check whether it reaches zero. If yes, it<\/p>\n

will delete itself.<\/p>\n

The correct deletion of a COM object depends on the correct<\/p>\n

operation of the client. If one client calls AddRef<\/strong> or Release<\/strong><\/p>\n

incorrectly, the COM object may be in memory when it should be deleted, or<\/p>\n

deleted when some one is still using it. Especially, if you call any method<\/p>\n

after the last Release<\/strong> call is made, you are stepping into OS\u2019s<\/p>\n

territory and your program will be shut down.<\/p>\n

<\/a><\/a>3.3.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>Life Time Control of a DLL Server<\/span><\/h2>\n

A DLL server is both loaded and unloaded by the COM rum<\/p>\n

time. When a client calls DllGetClassObject<\/strong> with the REFCLSID<\/strong> of<\/p>\n

a coclass in the server, SCM will look up the System Registry, find the<\/p>\n

directory of the server, load the server up, then call its exported function DllGetClassObject<\/strong>.<\/p>\n

A DLL server has two global ULONG<\/strong> counts affecting<\/p>\n

its life time control: g_objCount<\/strong> and g_lockCount<\/strong>. The former one<\/p>\n

indicates the number of live COM objects in the server and the latter one the<\/p>\n

number of locks imposed by clients on the server.<\/p>\n

The constructor of a coclass and a class factory in a DLL is<\/p>\n

supposed to increment the g_objCount<\/strong>. Its destructor is supposed to<\/p>\n

decrement g_objCount<\/strong>. On the other hand, for performance reason, a<\/p>\n

client may decide to to load the server into memory first, and create COM<\/p>\n

objects later. To lock the server, he calls its LockServer<\/strong> method<\/p>\n

passing TRUE, which will then increment the g_lockCount<\/strong>. To release the<\/p>\n

lock, the client calls the same method passing FALSE.<\/p>\n

Only when both of these two locks reaches zero, will the<\/p>\n

DLL\u2019s exported function DllCanUnloadNow<\/strong> return true. SCM will call this<\/p>\n

function at intervals to check whether the server can be unloaded. If yes it<\/p>\n

will unload the DLL from the memory. If a client wants the SCM to check this<\/p>\n

function and unload the server immediately if possible, it can call API<\/p>\n

function CoFreeUnusedLibraries<\/strong>.<\/p>\n

Because DLL class factories also have to delete themselves,<\/p>\n

the server can not be unloaded before all objects including class objects are<\/p>\n

done. That\u2019s why in DLL server class factories also affect the server reference<\/p>\n

counting.<\/p>\n

<\/a><\/a>3.4.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>EXE Server in Raw C++ Code<\/span><\/h2>\n

Because coclasses in EXE server are the same as those in DLL<\/p>\n

server, and class factories has only one difference that it does not affect any<\/p>\n

reference count, their code is omitted here:<\/p>\n

\u00a0<\/span><\/p>\n

<\/a>DWORD g_allLocks;<\/span><\/p>\n

\u00a0<\/span><\/p>\n

int APIENTRY WinMain(HINSTANCE hInstance,<\/span><\/p>\n

HINSTANCE hPrevInstance,<\/span><\/p>\n

LPSTRlpCmdLine,<\/span><\/p>\n

intnCmdShow)<\/span><\/p>\n

{<\/span><\/p>\n

<\/a>CoInitialize(NULL);<\/span><\/p>\n

\u00a0<\/span><\/p>\n

\/\/<\/span><\/p>\n

register the type lib<\/p>\n

ITypeLib* pTLib = NULL;<\/p>\n

LoadTypeLibEx(L”AnyEXETypeInfo.tlb”, REGKIND_REGISTER,<\/p>\n

&pTLib);<\/p>\n

pTLib->Release();<\/p>\n

if(strstr(lpCmdLine, “\/Embedding”) || strstr(lpCmdLine,<\/p>\n

“-Embedding”))<\/p>\n

{<\/span><\/p>\n

<\/a>AnyClassFactory cf<\/span><\/strong>; \/\/ class factories created as<\/span><\/p>\n

local objects<\/p>\n

\u00a0<\/span><\/p>\n

DWORD regID = 0;<\/p>\n

CoRegisterClassObject(CLSID_Any,<\/p>\n

(IClassFactory*)&cf,<\/p>\n

CLSCTX_LOCAL_SERVER,<\/p>\n

REGCLS_MULTIPLEUSE,<\/p>\n

&regID);<\/span><\/p>\n

MSG ms;<\/p>\n

while(GetMessage(&ms, 0, 0, 0))<\/p>\n

{<\/p>\n

TranslateMessage(&ms);<\/p>\n

DispatchMessage(&ms);<\/p>\n

}<\/p>\n

CoRevokeClassObject(regID);<\/p>\n

}<\/span><\/p>\n

\u00a0<\/span><\/p>\n

CoUninitialize();<\/p>\n

return 0;<\/p>\n

}<\/span><\/p>\n

\u00a0<\/span><\/p>\n

void Lock()<\/span><\/p>\n

{<\/span><\/p>\n

++g_allLocks;<\/span><\/p>\n

}<\/span><\/p>\n

\u00a0<\/span><\/p>\n

void UnLock()<\/span><\/p>\n

{<\/span><\/p>\n

–g_allLocks;<\/p>\n

if(g_allLocks == 0)<\/p>\n

PostQuitMessage<\/span><\/strong>(0);<\/span><\/p>\n

}<\/span><\/p>\n

\u00a0<\/span><\/p>\n

<\/a><\/a>3.5.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>Life Time Control of a Coclass and Class Factory<\/span><\/h2>\n

in an EXE Server<\/p>\n

<\/a><\/h2>\n

Coclasses in an EXE server works exactly like those in a DLL<\/p>\n

server.<\/p>\n

Class objects in an EXE server has one difference from those<\/p>\n

in a DLL server: they don’t affect any reference count \u2013 neither their own nor<\/p>\n

the server\u2019s. This is because they are created in WinMain<\/strong> as local<\/p>\n

objects on the stack, so they do not need to be explicitly deleted. When all<\/p>\n

coclass objects are done, WinMain<\/strong> will end, and when WinMain<\/strong><\/p>\n

ends, all class objects go out of scope.<\/p>\n

So EXE class factories use dummy implementation for AddRef<\/strong><\/p>\n

and Release<\/strong>: they simply returns constants like 10 or 20. The rest of the<\/p>\n

class factory are the same like those in a DLL server.<\/p>\n

<\/a><\/a>3.6.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>Life Tme Control of an EXE Server<\/span><\/h2>\n

A DLL server can not be run independently. It is started by<\/p>\n

the client\u2019s thread. It only has some exported functions such as DllGetClassObject<\/strong><\/p>\n

for clients to call. It can not unload itself. In comparison, an EXE server has<\/p>\n

its main thread. When an EXE is started, the main thread runs global function WinMain<\/strong>.<\/p>\n

When it reaches its end bracket, the whole server process ends just like normal<\/p>\n

applications.<\/p>\n

Unlike a DLL server which uses two global counts, an EXE<\/p>\n

server has only one global count g_allLocks<\/strong> for life time control.<\/p>\n

Whenever a coclass is instantiated, its constructor will<\/p>\n

call global function Lock,<\/strong> which will increase the lock count. Whenever<\/p>\n

it is destroyed, its destructor will call a global UnLock<\/strong>, which will<\/p>\n

decrease the lock, then check whether it is zero. If yes, post an \u201cexit\u201d<\/p>\n

message to end the dummy message look. Class factory’s LockServer<\/strong> method<\/p>\n

also calls Lock<\/strong> and UnLock<\/strong>. So the global variable UnLock<\/strong><\/p>\n

controls the EXE server life time.<\/p>\n

Class factory’s constructor and destructor doesn’t call Lock<\/strong><\/p>\n

and Unlock<\/strong>.<\/p>\n

<\/a><\/a>3.7.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>Nomal EXE Application vs. EXE Server<\/span><\/h2>\n

An EXE server can be designed as purely a server, or it can<\/p>\n

be designed to be able to server both as a server which is loaded as terminated<\/p>\n

by the COM run time, and an application with user interface which is started<\/p>\n

and ended by the user. How the program is run is decided by the command-line<\/p>\n

argument \u201cEmbedding<\/strong>\u201d.<\/p>\n

When COM run time starts the EXE as a server, it will invoke<\/p>\n

it with argument \u201cEmbedding<\/strong>\u201d. So WinMain<\/strong> knows that it is<\/p>\n

launched as a server. It will create the class factory objects for all the<\/p>\n

coclasses the server contains, register each of them in the Running Object<\/p>\n

Table by calling CoRegisterClassObject<\/strong>, then enter a dummy message loop<\/p>\n

and wait infinitely for an \u201cExit\u201d message. When the server’s global Unlock<\/strong><\/p>\n

function discovers that the server lock reaches zero, it will post an \u201cExit\u201d<\/p>\n

message to end the message loop. Then function CoRevokeClassObject<\/strong> will<\/p>\n

be called for each class object. Then WinMain<\/strong> ends.<\/p>\n

When user starts the EXE as an application, he will not put<\/p>\n

argument \u201cEmbedding<\/strong>\u201d. So WinMain<\/strong> knows that it is launched as an<\/p>\n

application. Instead of doing the above things, it will create and show its<\/p>\n

user interfaces.<\/p>\n

<\/a><\/a>3.8.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>Example of EXE Server’s WinMain<\/span><\/h2>\n

To register and unregister a class object CoCarClassFactory<\/p>\n

to the running object table:<\/p>\n

\u00a0<\/span><\/p>\n

<\/a>DWORD g_allLocks = 0<\/span><\/strong>;<\/span><\/p>\n

\u00a0<\/span><\/p>\n

int APIENTRY WinMain<\/span><\/strong>(HINSTANCE hInstance,<\/span><\/p>\n

HINSTANCE hPrevInstance,<\/span><\/p>\n

LPSTRlpCmdLine,<\/span><\/p>\n

intnCmdShow)<\/span><\/p>\n

{<\/span><\/p>\n

<\/a>CoInitialize(NULL);<\/span><\/p>\n

\u00a0<\/span><\/p>\n

if(strstr(lpCmdLine,<\/span><\/p>\n

“\/Embedding”) || strstr(lpCmdLine, “-Embedding”))<\/p>\n

{<\/span><\/p>\n

<\/a>CoCarClassFactory<\/span><\/strong> carClassFactory<\/span><\/strong>;<\/span><\/p>\n

DWORD regID = 0;<\/span><\/p>\n

CoRegisterClassObject<\/span><\/strong>(CLSID_CoCar,<\/span><\/p>\n

 <\/p>\n

(IClassFactory*)&carClassFactory<\/span><\/strong>,<\/p>\n

 <\/p>\n

CLSCTX_LOCAL_SERVER,<\/p>\n

REGCLS_MULTIPLEUSE, &regID);<\/p>\n

MSG ms;<\/span><\/p>\n

while(GetMessage(&ms, 0, 0, 0))<\/span><\/p>\n

{<\/span><\/p>\n

TranslateMessage(&ms);<\/span><\/p>\n

DispatchMessage(&ms);<\/span><\/p>\n

}<\/span><\/p>\n

CoRevokeClassObject<\/span><\/strong>(regID);<\/span><\/p>\n

}<\/span><\/p>\n

else<\/span><\/p>\n

{<\/span><\/p>\n

\/\/ Work as a normal application<\/span><\/p>\n

}<\/span><\/p>\n

\u00a0<\/span><\/p>\n

CoUninitialize();<\/span><\/p>\n

return 0;<\/span><\/p>\n

}<\/span><\/p>\n

<\/a><\/a>4.\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h1>\n

 <\/p>\n

<\/a>Client Invoking Server<\/span><\/h1>\n

<\/a><\/a>4.1.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>Accessing DLL and EXE Servers using Class<\/span><\/h2>\n

Factories<\/p>\n

<\/a><\/h2>\n

There are two steps to access a server (DLL server or EXE<\/p>\n

server alike) through class factories:<\/p>\n

1.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span>Client<\/p>\n

calls CoGetClassObject<\/strong> providing the REFCLSID<\/strong> of the coclass,<\/p>\n

which searches the System Registry, loads up the server if it is not yet<\/p>\n

loaded, calls the server’s exported function DllGetClassObject<\/strong>, which<\/p>\n

returns its IClassFactory<\/strong> pointer;<\/p>\n

2.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span>Client<\/p>\n

calls IClassFactory::CreateInstance<\/strong> with the REFIID<\/strong> of an<\/p>\n

interface of the coclass, which returns the interface pointer;<\/p>\n

COM library API function CoGetClassObject<\/strong> calls the<\/p>\n

COM server\u2019s DllGetClassObject<\/strong> to acquire a class factory reference:<\/p>\n

\u00a0<\/span><\/p>\n

<\/a>HRESULT CoGetClassObject<\/span><\/strong>(<\/span><\/p>\n

REFCLSID rclsid,<\/p>\n

DWORD<\/span><\/p>\n

dwClsContext,<\/p>\n

COSERVERINFO * pServerInfo,<\/p>\n

REFIID riid,<\/p>\n

LPVOID * ppv);<\/p>\n

COSERVERINFO<\/strong> is a structure to carry information for<\/p>\n

remote servers, which should be NULL if you are invoking in-proc or local<\/p>\n

servers.<\/p>\n

Then you can acquire from the IClassFactory<\/strong> interface<\/p>\n

the interface you want.<\/p>\n

Example:<\/p>\n

Use AppWizard’s option “Win32 Console Application”<\/p>\n

and “Empty Project” to create a totally empty project. Insert the<\/p>\n

iid.cpp file into the project, and put the following lines into the global file<\/p>\n

“ProjectName.cpp”:<\/p>\n

\u00a0<\/span><\/p>\n

#include “..\\cardll\\interfaces.h<\/span><\/strong>“<\/span><\/p>\n

#include “..\\cardll\\iid.h<\/span><\/strong>“<\/span><\/p>\n

#include <iostream.h><\/span><\/p>\n

\/\/ Note: interface definition<\/span><\/p>\n

“interface.h” should be included prior to<\/p>\n

\/\/ GUID definition “iid.h”<\/span><\/p>\n

\u00a0<\/span><\/p>\n

void main(int argc, char* argv[])<\/span><\/p>\n

{<\/span><\/p>\n

CoInitialize<\/span><\/strong>(NULL);<\/span><\/p>\n

IClassFactory * pClassFactory = NULL;<\/p>\n

HRESULT hr = CoGetClassObject<\/span><\/strong>(<\/p>\n

CLSID_Car,<\/p>\n

CLSCTX_SERVER,<\/p>\n

NULL,<\/p>\n

IID_IClassFactory,<\/p>\n

(void **) &pClassFactory);<\/p>\n

if(FAILED(hr)) \/\/ in the following code this error checking is omitted<\/p>\n

{<\/span><\/p>\n

cout << “CoGetClassObject failed!\\n”;<\/p>\n

return;<\/p>\n

}<\/span><\/p>\n

\u00a0<\/span><\/p>\n

IRegistration * pRegist = NULL;<\/p>\n

hr<\/span><\/p>\n

= pClassFactory->CreateInstance<\/span><\/strong>(<\/p>\n

<\/a>NULL, <\/span><\/p>\n

IID_IRegistration,<\/p>\n

(void **) &pRegist);<\/p>\n

\u00a0<\/span><\/p>\n

BSTR<\/span><\/p>\n

bstr = SysAllocString(L”Frank Liu”);<\/p>\n

hr<\/span><\/p>\n

= pRegist->SetOwner<\/span><\/strong>(bstr);<\/p>\n

SysFreeString(bstr);<\/p>\n

\u00a0<\/span><\/p>\n

hr<\/span><\/p>\n

= pRegist->GetOwner<\/span><\/strong>(&bstr);<\/p>\n

char buf[80];<\/p>\n

wcstombs(buf, bstr, 80);<\/p>\n

cout << “Owner of the car is: ” << buf <<<\/p>\n

endl;<\/p>\n

\u00a0<\/span><\/p>\n

IStatus * pStatus = NULL;<\/p>\n

pRegist->QueryInterface(IID_IStatus, (void **)&pStatus);<\/p>\n

\u00a0<\/span><\/p>\n

hr<\/span><\/p>\n

= pStatus->SetSpeed<\/span><\/strong>(120);<\/p>\n

int<\/span><\/p>\n

nSpeed;<\/p>\n

hr<\/span><\/p>\n

= pStatus->GetSpeed<\/span><\/strong>(&nSpeed);<\/p>\n

cout << “Speed of the car is now ” << nSpeed<\/p>\n

<< endl;<\/p>\n

\u00a0<\/span><\/p>\n

return;<\/p>\n

}<\/span><\/p>\n

<\/a><\/a>4.2.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>Accessing Server with CoCreateInstance<\/span><\/h2>\n

COM library API function CoCreateInstance<\/strong> wraps the<\/p>\n

two function calls \u2013 CoGetClassObject<\/strong> and IClassFactory::CreateInterface<\/strong>:<\/p>\n

\u00a0<\/span><\/p>\n

#include “stdafx.h”<\/span><\/p>\n

\u00a0<\/span><\/p>\n

\/\/ The following two header files are<\/span><\/p>\n

generated by MIDL compiler.<\/p>\n

\/\/ Alternatively, you can import the type<\/span><\/p>\n

library as instructed in<\/p>\n

\/\/ Chapter IDL.<\/span><\/p>\n

#include “..\\test\\test.h”<\/span><\/p>\n

#include “..\\test\\test_i.c”<\/span><\/p>\n

\u00a0<\/span><\/p>\n

int main(int argc, char* argv[])<\/span><\/p>\n

{<\/span><\/p>\n

CoInitialize(NULL);<\/span><\/p>\n

<\/a>IAny<\/span><\/strong> *<\/span><\/strong> pAny<\/span><\/strong> = NULL;<\/span><\/p>\n

\u00a0<\/span><\/p>\n

<\/a>HRESULT hr = CoCreateInstance<\/span><\/strong>(<\/span><\/p>\n

CLSID_Any, <\/span><\/p>\n

NULL, <\/span><\/p>\n

CLSCTX_INPROC_SERVER, <\/span><\/p>\n

IID_IAny, <\/span><\/p>\n

<\/a>(void **)&pAny<\/span><\/strong>);<\/span><\/p>\n

\u00a0<\/span><\/p>\n

if(FAILED(hr))<\/span><\/p>\n

printf(“CoCreateInstance<\/span><\/p>\n

failed!”);<\/p>\n

<\/a>hr = pAny<\/span><\/strong>->Hi();<\/span><\/p>\n

<\/a>pAny<\/span><\/strong>->Release();<\/span><\/p>\n

return<\/span><\/p>\n

0;<\/p>\n

}<\/span><\/p>\n

<\/a><\/a>4.3.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>Execution Context<\/span><\/h2>\n

There are four execution contexts you can use when calling CoCreateInstance<\/p>\n

or CoCreateInstanceEx:<\/p>\n

\u00a0<\/span><\/p>\n

<\/a>CLSCTX_INPROC_SERVER<\/span><\/p>\n

<\/a>CLSCTX_INPROC_HANDLER<\/span><\/p>\n

CLSCTX_LOCAL_SERVER<\/span><\/p>\n

CLSCTX_REMOTE_SERVER<\/span><\/p>\n

CLSCTX_SERVER is an OR of the three server contexts.<\/p>\n

<\/a><\/a>5.\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h1>\n

 <\/p>\n

<\/a>IDL<\/span><\/h1>\n

<\/a><\/a>5.1.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>Interface Definition Language (IDL)<\/span><\/h2>\n

With a server created purely in C++, without using IDL<\/p>\n

compiler,a client have to make use of<\/p>\n

the two header files which defines the interfaces and the guids. Because both<\/p>\n

these two files are in C++ syntax, clients written in other languages such as<\/p>\n

VB or Java can not invoke it. So such a COM server is not language independent.<\/p>\n

Therefore we need a language-independent way to describe the<\/p>\n

interfaces of a COM server. Microsoft IDL (MIDL) is used for this purpose.<\/p>\n

An IDL file does not contain any implementation information.<\/p>\n

Therefore you can not define a class in IDL with implemented methods. You can<\/p>\n

only define interfaces in IDL and implement them in a specific language such as<\/p>\n

VC or VB. However, you can define data structures which doesn’t contain any<\/p>\n

implementation.<\/p>\n

<\/a><\/a>5.2.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>Type Library<\/span><\/h2>\n

When you define a COM server in an IDL file say Any.idl<\/strong><\/p>\n

and send it to VC’s integrated MIDL compiler, it will generate a C++ header<\/p>\n

file Any.h<\/strong> (which serves as interface definition), and a guid definition<\/p>\n

file Any_i.c<\/strong> for C++ clients, and a type library file Any.tlb<\/strong> containing<\/p>\n

all information of a COM server, which is in a language-independent binary<\/p>\n

format, therefore can be understood by different languages such as VC, VB,<\/p>\n

BJ++, etc.<\/p>\n

When a C++ client wants to make use of type library, he can<\/p>\n

use #import to import the type library. When a VB client wants to invoke a COM<\/p>\n

server and design time, he can select from the list of registered type<\/p>\n

libraries from the “Project” | “Preferences” dialog. If one<\/p>\n

type library is not registered, he can also browse to select one.<\/p>\n

To register a type library, under entry HKEY_CLASSES_ROOT\\TypeLib<\/strong>,<\/p>\n

you should create an entry of the guid of the type library, under which you<\/p>\n

specify the help string and directory of this type library. This is why VB can<\/p>\n

show you a list of registered type libraries. You should add a TypeLib<\/strong><\/p>\n

entry under the HKEY_CLASSES_ROOT\\CLSID<\/strong> of each coclasses contained in<\/p>\n

this type library, so that SCM can find the type library guid from a coclass.<\/p>\n

All these things can be done by ATL.<\/p>\n

In C++, binary information defined by IDL is stored in both<\/p>\n

the .dll<\/strong> file and the .tlb<\/strong> file. In Visual Basic it is only<\/p>\n

stored in DLL file. A EXE server will have its info in the EXE file.<\/p>\n

<\/a><\/a>5.3.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>IDL Compatible Data Types<\/span><\/h2>\n

If you only use the following IDL data types, your<\/p>\n

interfaces can be used by all COM-enabled interfaces:<\/p>\n

\u00a0<\/span><\/p>\n

VARIANT_BOOL, double, float, long, short,<\/span><\/p>\n

BSTR, DATE, IDispatch*, IUnknown*, VARIANT, CY\/CURRENCY, SAFEARRAY<\/p>\n

However, when you use other types such as ULONG or HRESULT<\/p>\n

in your IDL, they are also OK, because they have been defined by typedef<\/strong><\/p>\n

in “wtypes.idl<\/strong>” as IDL data types. You do not need to import<\/p>\n

“wtypes.idl<\/strong>“, because it will be imported by “oaidl.idl<\/strong>“.<\/p>\n

<\/a><\/a>5.4.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>Defining Coclasses, Interfaces and Libraries in<\/span><\/h2>\n

IDL<\/p>\n

<\/a><\/h2>\n

IDL file<\/p>\n

of an empty COM server looks like<\/p>\n

\u00a0<\/span><\/p>\n

import “oaidl.idl”;<\/span><\/p>\n

\u00a0<\/span><\/p>\n

[<\/span><\/p>\n

uuid<\/span><\/strong>(7013DBBD-A9FC-11D5-9866-E39F283C9930),<\/span><\/p>\n

version<\/span><\/strong>(1.0),<\/span><\/p>\n

helpstring<\/span><\/strong>(“Test 1.0 Type Library”)<\/span><\/p>\n

]<\/span><\/p>\n

library<\/span><\/strong> TESTLib<\/span><\/p>\n

{<\/span><\/p>\n

importlib(“stdole32.tlb”);<\/p>\n

};<\/span><\/p>\n

“oaidl.idl<\/strong>” is the only IDL file you must<\/p>\n

import in your IDL file. Type library “stdole32.tlb<\/strong>” is the<\/p>\n

standard OLE type library, which must be imported by any type library.<\/p>\n

\u00a8\u00a0\u00a0\u00a0 <\/span><\/span><\/span>Adding<\/h3>\n

a coclass<\/p>\n

To add a new coclass, add the following coclass declaration<\/p>\n

lines in<\/strong> the library block:<\/p>\n

\u00a0<\/span><\/p>\n

[<\/span><\/p>\n

uuid(7013DBCD-A9FC-11D5-9866-E39F283C9930),<\/span><\/p>\n

helpstring(“MyCom<\/span><\/p>\n

Class”)<\/p>\n

]<\/span><\/p>\n

coclass<\/span><\/p>\n

MyCom<\/p>\n

{<\/span><\/p>\n

};<\/span><\/p>\n

\u00a8\u00a0\u00a0\u00a0 <\/span><\/span><\/span>Adding<\/h3>\n

an interface and its methods<\/p>\n

We can use AppWizard to add coclasses and their default<\/p>\n

interfaces, but we have to add additional interfaces ourselves. For each<\/p>\n

interface, we add its declaration in front of the library block. Attribute<\/p>\n

“object<\/strong>” indicates that this is a COM interface not a DCE IDL<\/p>\n

interface.<\/p>\n

\u00a0<\/span><\/p>\n

[<\/span><\/p>\n

object<\/span><\/strong>,<\/span><\/p>\n

uuid<\/span><\/strong>(7013DBCB-A9FC-11D5-9866-E39F283C9930),<\/span><\/p>\n

helpstring<\/span><\/strong>(“ICOMClass1 Interface”)<\/span><\/p>\n

]<\/span><\/p>\n

interface<\/span><\/strong> IMyInterf : IUnknown<\/span><\/p>\n

{<\/span><\/p>\n

[helpstring(“method<\/span><\/p>\n

GetBalance”)]<\/p>\n

HRESULT GetBalance([in] int aa, [out] LONG *<\/span><\/p>\n

bb);<\/p>\n

[helpstring(“method<\/span><\/p>\n

Deposit”)]<\/p>\n

HRESULT<\/span><\/p>\n

Deposit([in] int aa);<\/p>\n

};<\/span><\/p>\n

Then we add the interface name in the coclass definition:<\/p>\n

\u00a0<\/span><\/p>\n

[<\/span><\/p>\n

uuid(7013DBCD-A9FC-11D5-9866-E39F283C9930),<\/span><\/p>\n

helpstring(“MyCom<\/span><\/p>\n

Class”)<\/p>\n

]<\/span><\/p>\n

coclass<\/span><\/p>\n

MyCom<\/p>\n

{<\/span><\/p>\n

[default<\/span><\/strong>] interface IMyInterf;<\/span><\/p>\n

};<\/span><\/p>\n

the interface with [default]<\/strong> attribute is the default<\/p>\n

interface of the coclass.<\/p>\n

An interface should belong to a coclass. A standard-alone<\/p>\n

interface which does not belong to any coclass is alowed by MIDL compiler and<\/p>\n

can be implemented manually, but it is not shown when using Implement Interface<\/p>\n

Wizard.<\/p>\n

Then we should let the coclass inherit from the interface,<\/p>\n

and in ATL we should add a COM map entry for the interface.<\/p>\n

<\/a><\/a>5.5.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>Defining Data Structures in IDL<\/span><\/h2>\n

If your server needs to use a custom type (a class or a<\/p>\n

structure) internally, you can define the new type in a normal header file<\/p>\n

(plus cpp file if necessary) and #include the header file wherever it is used.<\/p>\n

However, if this custom type is used as an argument in a<\/p>\n

method of an interface which needs to be transfered by the marshaller, then you<\/p>\n

should define the custom type in your main IDL file, or in a separate IDL file<\/p>\n

and import it in your main IDL file.<\/p>\n

Then, when MIDL compiler compiles the main IDL file, the<\/p>\n

header file it generates will contain the definition of the custom type. If the<\/p>\n

custom type is defined in a separate IDL file, then you have to compile the<\/p>\n

separate IDL file first, then the main IDL file. Then the header file generated<\/p>\n

from the main IDL file will automatically include the header file generated<\/p>\n

from the separate IDL file.<\/p>\n

Because the main IDL file either contains the definition of<\/p>\n

the custom type or imports its definition, the client who invokes this server<\/p>\n

can directly use the custom type.<\/p>\n

If the custom type contains any variable-length array<\/p>\n

member, you must put size_is<\/strong> attribute in front of the variable-length<\/p>\n

data member to inform the marshaller of the member’s size:<\/p>\n

\u00a0<\/span><\/p>\n

typedef struct {<\/span><\/p>\n

short sSize;<\/p>\n

[size_is<\/span><\/strong>(sSize)] short<\/span><\/strong><\/span><\/p>\n

sArray[];<\/p>\n

} Group;<\/span><\/p>\n

Also notice that the array member is represented by array<\/p>\n

syntax “short sArray[ ]<\/strong>” not pointer syntax “short *<\/strong><\/p>\n

pShort”. For some reason the latter one doesn’t work.<\/p>\n

<\/a><\/a>5.6.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>Defining Enums in IDL<\/span><\/h2>\n

\u00a0<\/span><\/p>\n

[uuid(442F….804), v1-enum<\/span><\/strong>]<\/span><\/p>\n

typedef enum<\/span><\/strong><\/span><\/p>\n

{<\/p>\n

HATCH = 0,<\/p>\n

SOLID = 1,<\/p>\n

POLKADOT<\/p>\n

} FILLTYPE;<\/span><\/p>\n

Attribute v1-enum<\/strong> indicates that these enums are<\/p>\n

32-bit, which is more efficient in marshalling.<\/p>\n

<\/a><\/a>5.7.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>MkTypLib Compatible Option<\/span><\/h2>\n

Each VC project has a “MkTypLib Compatible”<\/p>\n

option. This option is found under “Project | Settings | MIDL”. This<\/p>\n

is by default set, which means that all IDL files must conform to older ODL<\/p>\n

syntax. You should turn it off. In a project generated by ATL COM AppWizard, it<\/p>\n

is turned off.<\/p>\n

<\/a><\/a>5.8.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>MIDL Generated Files<\/span><\/h2>\n

Suppose the IDL file name is Shapes.idl, the files generated<\/p>\n

by MIDL are:<\/p>\n

1.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/p>\n

Shapes.hInterface<\/p>\n

definition<\/p>\n

2.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/p>\n

Shapes.tlbbinary<\/p>\n

type library<\/p>\n

3.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/p>\n

Shapes_i.cdefinition<\/p>\n

of all guids<\/p>\n

4.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/p>\n

Shapes_p.c and dlldate.cused to build proxy and stub DLLs for remote accessing<\/p>\n

<\/a><\/a>5.9.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>Importing Type Library<\/span><\/h2>\n

In C++, to invoke a server or implement an interface defined<\/p>\n

in it through its type library is to #import the type library wherever you need<\/p>\n

it \u2013 in the *.h or *.cpp file. When you #import a type library say Shapes.tlb<\/strong>,<\/p>\n

the compiler will generate two C++ files: Shapes.tlh<\/strong> and Shapes.tli<\/strong>,<\/p>\n

which contains definitions for the interfaces, guids and and smart pointers.<\/p>\n

Both files are placed in the output directory e.g. “debug”, and then<\/p>\n

read and compiled by the compiler as if they are included. So after you compile<\/p>\n

the project, you can actually comment out the #import line and #include the tlh<\/strong><\/p>\n

file.<\/p>\n

A typical #import line looks like:<\/p>\n

\u00a0<\/span><\/p>\n

#import<\/span><\/strong> “D:\\icp97\\pc\\core\\code\\ICPCore.tlb” \\<\/span><\/p>\n

no_namespace, named_guids,<\/span><\/strong><\/p>\n

raw_native_types, raw_interfaces_only<\/p>\n

\u00a8\u00a0\u00a0\u00a0 <\/span><\/span><\/span>no_namespace<\/h3>\n

If you do not put the “no_namespace<\/strong>“<\/p>\n

attribute after the #import, most sections in the generated tlh<\/strong> file<\/p>\n

will be enclosed in a namespace block, which is named after the type library<\/p>\n

name. This is useful to prevent name conflicts between names used in your<\/p>\n

client program and names imported from the COM server. To use the names in the<\/p>\n

COM server, you should put the following declaration immediately after the<\/p>\n

#import line (the name of the type library is ICPCore.tlb):<\/p>\n

\u00a0<\/span><\/p>\n

using namespace ICPCore;<\/span><\/p>\n

By putting the “no_namespace<\/strong>” attribute,<\/p>\n

the namespace declaration in the generated tlh<\/strong> file will be supressed.<\/p>\n

Therefore all names in the tlh<\/strong> file are in the same namespace as your<\/p>\n

client program. You can directly quote them.<\/p>\n

\u00a8\u00a0\u00a0\u00a0 <\/span><\/span><\/span>named_guids<\/h3>\n

Attribute “named_guids<\/strong>” instructs the<\/p>\n

compiler to define the guids contained in the tlh<\/strong> file with CLSID_, IID_<\/p>\n

and LIB_ prefix.<\/p>\n

If a type library includes references to types defined in<\/p>\n

other type libraries, then the .TLH file will include comments of the following<\/p>\n

sort:<\/p>\n

\u00a0<\/span><\/p>\n

\/\/ Cross-referenced type libraries:<\/span><\/p>\n

\/\/<\/span><\/p>\n

\/\/<\/span><\/p>\n

#import “c:\\path\\typelib0.tlb”<\/p>\n

\u00a8\u00a0\u00a0\u00a0 <\/span><\/span><\/span>raw_native_types<\/h3>\n

By default, the high-level error-handling methods use the<\/p>\n

COM support classes _bstr_t<\/strong> and _variant_t<\/strong> in place of the BSTR<\/strong><\/p>\n

and VARIANT<\/strong> data types and raw COM interface pointers. These classes<\/p>\n

encapsulate the details of allocating and deallocating memory storage for these<\/p>\n

data types, and greatly simplify type casting and conversion operations.<\/p>\n

This attribute is used to disable the use of these COM<\/p>\n

support classes in the high-level wrapper functions, and force the use of<\/p>\n

low-level data types instead.<\/p>\n

\u00a8\u00a0\u00a0\u00a0 <\/span><\/span><\/span>raw_interfaces_only<\/h3>\n

This attribute suppresses the generation of<\/p>\n

error-handling wrapper functions and __declspec(property) declarations that use<\/p>\n

those wrapper functions.<\/p>\n

It also causes the default prefix used in naming the<\/p>\n

non-property functions to be removed. Normally, the prefix is raw_<\/strong>.E.g., if a method of the original interface<\/p>\n

is called MyMethod<\/strong> in the IDL and type library, then in the *.tlh file<\/p>\n

generated by the #import from the type library, it will become raw_MyMethod<\/strong>.<\/p>\n

If this attribute is specified, the function names are directly from the type<\/p>\n

library.<\/p>\n

This attribute allows you to expose only the low-level<\/p>\n

contents of the type library.<\/p>\n

<\/a><\/a>5.10.\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>Smart Pointers<\/span><\/h2>\n

When VC compiler sees preprocessor directive #import *.tlb,<\/p>\n

it reads the type definition in the type library and generates smart pointer<\/p>\n

classes from IDL files, to wrap low-level functions calls such as CoCreateInstance<\/strong>,<\/p>\n

Release<\/strong>, InterfaceSupportsErrorInfo<\/strong>, GetErrorInfo<\/strong>, GetDescription<\/strong>,<\/p>\n

etc.. For interface IAccount<\/strong> and IDisplay<\/strong>, there will be smart<\/p>\n

pointer class IAccountPtr<\/strong> and IDisplayPtr<\/strong>.<\/p>\n

These smart pointers can automatically acquire interface<\/p>\n

reference with CoCreateInstance<\/strong>. You do not need to call QueryInterface<\/strong><\/p>\n

to acquire a new interface from the original one. You can just assign the<\/p>\n

original interface smart pointer to the new one. AddRef<\/strong> and Release<\/strong><\/p>\n

are also called automatically.<\/p>\n

When a when a smart pointer detects an error from the<\/p>\n

returned HRESULT, it will throw a _com_error<\/strong> exception. You can call its<\/p>\n

ErrorMessage<\/strong> method, which calls API function FormatMessage<\/strong> to<\/p>\n

return an explanation of the HRESULT, such as “Invalid pointer”. To<\/p>\n

retrieve the extra error information set with IErrorInfo<\/strong> objects, call _com_error<\/strong>‘s<\/p>\n

Description<\/strong> method.<\/p>\n

A smart pointer also supports IDL attribute [out, retval]<\/strong>.<\/p>\n

Because smart pointer classes are higher level than<\/p>\n

raw interface pointers, it is more error prone. I have once run into a job<\/p>\n

which can be done by using raw interface pointers but not smart pointer<\/p>\n

classes.<\/p>\n

To use smart pointer for interface IAccount<\/strong> and IDisplay<\/strong><\/p>\n

of coclass Account<\/strong> in server BankATL<\/strong>:<\/p>\n

\u00a0<\/span><\/p>\n

try{<\/span><\/p>\n

<\/a>IAccountPtr<\/span><\/strong> pAccount(“BankATL.Account.1”);<\/span><\/strong><\/strong><\/span><\/p>\n

\/*<\/span><\/p>\n

or you can say<\/p>\n

IAccountPtr pAccount;<\/p>\n

pAccount.CreateInstance<\/span><\/strong>(CLSID_Account);<\/p>\n

or<\/p>\n

IAccount pAccount(__uuidof<\/span><\/strong>(CAccount));<\/p>\n

*\/<\/span><\/p>\n

\u00a0<\/span><\/p>\n

int<\/span><\/p>\n

balance;<\/p>\n

pAccount->GetBalance(&balance);<\/p>\n

pAccount->Deposit(23);<\/p>\n

pAccount->GetBalance(&balance);<\/p>\n

\u00a0<\/span><\/p>\n

<\/a>IDisplayPtr pDisplay = pAccount;<\/span><\/strong><\/span><\/p>\n

pDisplay->Show();<\/p>\n

}<\/span><\/p>\n

catch(_com_error<\/span><\/strong><\/span><\/p>\n

&ex)<\/p>\n

{<\/span><\/p>\n

MessageBox(ex.ErrorMessage<\/span><\/strong>());<\/p>\n

}<\/span><\/p>\n

When you pass the ProgID to a smart pointer’s constructor, a<\/p>\n

CoCreateInstance<\/strong> call has already been done. Therefore, you should be<\/p>\n

cautious when you make a smart pointer a data member or especially a global<\/p>\n

variable \u2013 AfxOleInit<\/strong> must be called before the smart pointer is<\/p>\n

created.<\/p>\n

5.11.\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a><\/a>[retval]<\/span><\/h2>\n

Attribute<\/p>\n

<\/a><\/h2>\n

Parameter marked with “[ out, retval ]<\/strong>” can<\/p>\n

be used by smart pointers or other languages such as VB as logical return type.<\/p>\n

Suppose method Add<\/strong> of interface IMath<\/strong> implemented by coclass CMath<\/strong><\/p>\n

is defined as<\/p>\n

\u00a0<\/span><\/p>\n

HRESULT Add([in] long x, [in] long y, [out, retval]<\/span><\/strong> long * z);<\/span><\/p>\n

You can say<\/p>\n

\u00a0<\/span><\/p>\n

IMathPtr sp (__uuidof(CMath));<\/span><\/p>\n

long result<\/span><\/strong><\/span><\/p>\n

= sp->Add(111, 222);<\/p>\n

\/* which is equal to<\/span><\/p>\n

long result;<\/span><\/p>\n

sp->Add(111, 222, &result<\/span><\/strong>);<\/span><\/p>\n

*\/<\/span><\/p>\n

In VB:<\/p>\n

\u00a0<\/span><\/p>\n

<\/a>Dim c as New CMath<\/span><\/p>\n

Dim ans as Integer<\/span><\/p>\n

ans = c.Add(111, 222)<\/span><\/p>\n

<\/a><\/a>5.12.\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>[oleautomation] Compatible Data Types<\/span><\/h2>\n

Originally COM specifications was generated to be used only<\/p>\n

for C\/C++. Some of C\/C++\u2019s types doesn\u2019t map to other languages such as VB. If<\/p>\n

your COM component has an interface method with such a data type as parameter,<\/p>\n

other languages may not be able to call this method.<\/p>\n

To solve this problem, Microsoft developed a set of<\/p>\n

universal IDL data types that can map to all languages. It is based on VB\u2019s data<\/p>\n

type \u201cVariant\u201d. They are:<\/p>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
\n

Universal IDL Type<\/strong><\/p>\n<\/td>\n

\n

VB Mapping<\/strong><\/p>\n<\/td>\n

\n

J++ Mapping<\/strong><\/p>\n<\/td>\n

\n

C\/C++ Mapping<\/strong><\/p>\n<\/td>\n<\/tr>\n

\n

VARIANT_BOOL<\/p>\n<\/td>\n

\n

Boolean<\/p>\n<\/td>\n

\n

boolean<\/p>\n<\/td>\n

\n

VARIANT_BOOL<\/p>\n<\/td>\n<\/tr>\n

\n

double<\/p>\n<\/td>\n

\n

Double<\/p>\n<\/td>\n

\n

double<\/p>\n<\/td>\n

\n

double<\/p>\n<\/td>\n<\/tr>\n

\n

float<\/p>\n<\/td>\n

\n

Single<\/p>\n<\/td>\n

\n

float<\/p>\n<\/td>\n

\n

float<\/p>\n<\/td>\n<\/tr>\n

\n

long<\/p>\n<\/td>\n

\n

Long<\/p>\n<\/td>\n

\n

long<\/p>\n<\/td>\n

\n

long<\/p>\n<\/td>\n<\/tr>\n

\n

short<\/p>\n<\/td>\n

\n

Integer<\/p>\n<\/td>\n

\n

short<\/p>\n<\/td>\n

\n

short<\/p>\n<\/td>\n<\/tr>\n

\n

BSTR<\/p>\n<\/td>\n

\n

String<\/p>\n<\/td>\n

\n

java.lang.String<\/p>\n<\/td>\n

\n

BSTR<\/p>\n<\/td>\n<\/tr>\n

\n

DATE<\/p>\n<\/td>\n

\n

Date<\/p>\n<\/td>\n

\n

double<\/p>\n<\/td>\n

\n

DATE<\/p>\n<\/td>\n<\/tr>\n

\n

IDispatch *<\/p>\n<\/td>\n

\n

Object<\/p>\n<\/td>\n

\n

java.lang.Object<\/p>\n<\/td>\n

\n

IDispatch *<\/p>\n<\/td>\n<\/tr>\n

\n

IUnknown *<\/p>\n<\/td>\n

\n

Interface reference<\/p>\n<\/td>\n

\n

com.ms.com.IUnknown<\/p>\n<\/td>\n

\n

IUnknown *<\/p>\n<\/td>\n<\/tr>\n

\n

VARIANT<\/p>\n<\/td>\n

\n

Variant<\/p>\n<\/td>\n

\n

com.ms.com.Variant<\/p>\n<\/td>\n

\n

VARIANT<\/p>\n<\/td>\n<\/tr>\n

\n

CY\/CURRENCY<\/p>\n<\/td>\n

\n

Currency<\/p>\n<\/td>\n

\n

long<\/p>\n<\/td>\n

\n

CY\/CURRENCY<\/p>\n<\/td>\n<\/tr>\n

\n

SAFEARRAY<\/p>\n<\/td>\n

\n

Variant<\/p>\n<\/td>\n

\n

com.ms.com.SafeArray<\/p>\n<\/td>\n

\n

SAFEARRAY<\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

If your COM component\u2019s interface methods all use the above universal<\/p>\n

data types, then the component can be invoked by client programs written in all<\/p>\n

languages.<\/p>\n

In such a case, you\u2019d better put attribute [oleautomation]<\/strong><\/p>\n

in the interface declaration:<\/p>\n

\u00a0<\/span><\/p>\n

[<\/span><\/p>\n

object,<\/span><\/p>\n

uuid(C39A9A9A-1E04-11D6-9867-F05CFEE1FC30),<\/span><\/p>\n

oleautomation<\/span><\/strong>,<\/span><\/p>\n

helpstring(“IAny<\/span><\/p>\n

Interface”),<\/p>\n

pointer_default(unique)<\/span><\/p>\n

]<\/span><\/p>\n

interface<\/span><\/p>\n

IAny : IUnknown<\/p>\n

{<\/span><\/p>\n

[helpstring(“method<\/span><\/p>\n

Hi”)] HRESULT Hi([in] A a);<\/p>\n

};<\/span><\/p>\n

With this attribute, MIDL compiler will check that all interface<\/p>\n

methods use only universal data types. If not, e.g. a method has a parameter of<\/p>\n

a custom type say CEmployee * pEmployee, it will generate a warning message<\/p>\n

like \u201cinterface does not conform to [oleautomation] attribute\u201d.<\/p>\n

If you use dispinterface<\/strong> or dual interface than you<\/p>\n

have to stick to this standard.<\/p>\n

If your COM component comply to the [oleautomation]<\/strong><\/p>\n

standard, it can make use of COM\u2019s automatic data marshalling DLL oleaut32.dll<\/strong>.<\/p>\n

Otherwise you have to build and register your own stub\/proxy DLL server (MIDL<\/p>\n

will generate the make file for you so it is not difficult either).<\/p>\n

<\/a><\/a><\/a>6.\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span>Da<\/span><\/span><\/a>ta<\/span><\/span><\/span><\/h1>\n

Marshalling<\/p>\n

<\/a><\/a><\/a>6.1.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>When is Data Marshaller Needed<\/span><\/span><\/h2>\n

When designing a DLL server,<\/p>\n

you can simply use a pointer to pass into the server an array, just like a<\/p>\n

normal method call, because the DLL server is in-process and shares the same<\/p>\n

address space:<\/p>\n

\u00a0<\/span><\/p>\n

[id(1), helpstring(“method<\/span><\/p>\n

PassShorts”)]<\/p>\n

HRESULT PassShorts([in] short count, [in] short * pShort);<\/p>\n

\u00a0<\/span><\/p>\n

STDMETHODIMP CAny::PassShorts(short *<\/span><\/strong> pShort<\/span><\/strong>,<\/span><\/p>\n

int count)<\/p>\n

{<\/span><\/p>\n

char temp[80];<\/p>\n

\u00a0<\/span><\/p>\n

for(int i = 0; i < count; i++)<\/span><\/p>\n

{<\/span><\/p>\n

sprintf(temp, “%d \\n”, pShort[i]<\/span><\/strong>);<\/p>\n

MessageBox(NULL, temp, “Server”, MB_OK);<\/p>\n

}<\/span><\/p>\n

\u00a0<\/span><\/p>\n

return S_OK;<\/p>\n

}<\/span><\/p>\n

When it comes to EXE server, if you use the same code shown above,<\/p>\n

only pShort[0] has a legal value. If you try to access the succeeding array<\/p>\n

elements, the server will fail.<\/p>\n

This is because the server and the client are not in the<\/p>\n

same address space, the data transfer between the client and the server is<\/p>\n

taken care of by the marshaller. When the client passes a pointer to the server<\/p>\n

or vice versa, the receiver actually does not get a pointer pointing to the<\/p>\n

original location in the sender’s address space. Instead it gets a pointer to a<\/p>\n

copy of data in his own address space allocated by the marshaller. The<\/p>\n

marshaller transfers the data from the sender to the receiver.<\/p>\n

For a in-process method call, both the caller and the method<\/p>\n

are refering to the same piece of physical data (in case of pass-by-pointer),<\/p>\n

the reference itself doesn’t cause data flow. For a method call between a<\/p>\n

client and EXE server, however, a data reference itself will cause data flow,<\/p>\n

and therefore you must tell the marshaller the flow direction and the amount of<\/p>\n

data to be transfered.<\/p>\n

<\/a><\/a><\/a>6.2.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>Data Marshalling and Parameter Direction<\/span><\/span><\/h2>\n

Attrubutes<\/p>\n

<\/a><\/h2>\n

Data marshaller’s job is to allocate memory for the<\/p>\n

destination, and copy data from the corresponding source memory block to the<\/p>\n

allocated memory. The source and destination is decided by the parameter<\/p>\n

direction attributes [in]<\/strong> and [out]<\/strong>. The amount of memory to be<\/p>\n

allocated is decided by the type definition of the parameter and \u2013 if the<\/p>\n

parameter has a variable size like a variable-size array or structure \u2013 the<\/strong><\/p>\n

[size_is]attribute.<\/p>\n

Notice that when the parameter is a pointer, the<\/p>\n

marshaller will not only allocate memory for the pointer itself, but also for<\/p>\n

the memory block pointed by the pointer. Otherwise the destination side can not<\/p>\n

make any use of the pointer.<\/p>\n

When the direction attribute is [in]<\/strong>, before<\/strong><\/p>\n

the server method is called, marshaller allocates memory for the server and<\/p>\n

copies data from the client to server. When the attribute is [out]<\/strong>,<\/p>\n

marshaller allocates memory for the client and copies data from server to it after<\/strong><\/p>\n

the server method returns. When the attribute is [in, out]<\/strong>, the<\/p>\n

marshaller does the [in]<\/strong> process before the method call, then the [out]<\/strong><\/p>\n

process after the method returns.<\/p>\n

Because the marshaller copies data from the source<\/p>\n

to the allocated memory of the destination, the source must have allocated the<\/p>\n

corresponding memory before the marshalling process starts. If not, for<\/p>\n

example, the source only uses a pointer to NULL to call the destination, then<\/p>\n

run-time error will happen when marshaller accesses the memory pointeded by the<\/p>\n

source pointer and tries to copy data from it.<\/p>\n

Becaue the marshaller usually needs to copy some<\/p>\n

data from server’s memory back to the client after<\/strong> the server method<\/p>\n

returns, the server should never delete any allocated memory \u2013 no matter it is<\/p>\n

allocated by the server itself or the marshaller. The marshaller will<\/p>\n

deallocate all server memory after it finishes the marshalling process. In<\/p>\n

comparison, the client should always deallocate memory \u2013 no matter it is<\/p>\n

allocated by the client itself or the marshaller.<\/p>\n

Just as in-process method calls, if you want to get<\/p>\n

result from the called function, you must pass the parameter by pointer. If it<\/p>\n

is passed by value, the server may modify his copy of the parameter but the<\/p>\n

client-side parameter will remain unchanged. If the object to be passed itself<\/p>\n

is a pointer, then it should be passed by a double pointer.<\/p>\n

<\/a><\/a><\/a><\/a>6.3.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>CoTaskMemAlloc & CoTaskMemFree<\/span><\/span><\/span><\/h2>\n

To safely allocate<\/span><\/p>\n

the memory that may be accessed by the marshaller, or deallocate memory<\/p>\n

allocated by the marshaller, use method CoTaskMemAlloc<\/strong> and CoTaskMemFree<\/strong>,<\/p>\n

which are known by the marshaller:<\/p>\n

\u00a0<\/span><\/span><\/p>\n

LPVOID<\/span><\/span><\/p>\n

CoTaskMemAlloc(ULONG ulSize);<\/p>\n

void<\/span><\/span><\/p>\n

CoTaskMemFree(void *pv);<\/p>\n

The initial<\/span><\/p>\n

contents of the memory block returned by CoTaskMemAlloc<\/strong> are undefined.<\/p>\n

It may be larger than required because of the space required for alignment and<\/p>\n

for maintenance information.<\/p>\n

If the required<\/span><\/p>\n

memory size is zero, CoTaskMemAlloc<\/strong> allocates a zero-length item and<\/p>\n

returns a valid pointer to that item. If there is insufficient memory<\/p>\n

available, CoTaskMemAlloc<\/strong> returns NULL. Therefore, applications should<\/p>\n

always check the return value from this method, even when requesting small<\/p>\n

amounts of memory.<\/p>\n

To initialize the<\/span><\/p>\n

allocated memory, use C run time library method memset<\/strong>. Notice that it<\/p>\n

is always safer to initialize the allocated memory before passing it to<\/p>\n

anywhere. Errors may be caused by passing uninitialized memory.<\/p>\n

Example:<\/span><\/p>\n

\u00a0<\/span><\/strong><\/span><\/p>\n

short<\/span><\/span><\/p>\n

sSize = 100;<\/p>\n

short * <\/span><\/strong>pShort;<\/span><\/span><\/p>\n

pShort<\/span><\/span><\/p>\n

= reinterpret_cast<short *>(CoTaskMemAlloc(sSize<\/span><\/strong><\/p>\n

* sizeof(short)));<\/p>\n

if(pShort<\/span><\/span><\/p>\n

== NULL)<\/p>\n

{…}<\/span><\/span><\/p>\n

::memset<\/span><\/strong>(pShort, 0, sSize);<\/span><\/span><\/p>\n

…<\/span><\/span><\/p>\n

<\/a>CoTaskMemFree(pShort)<\/span><\/strong>;<\/span><\/span><\/p>\n

<\/a><\/a>6.4.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>Example of Passing Arrays<\/span><\/span><\/h2>\n

\u00a8\u00a0\u00a0\u00a0 <\/span><\/span><\/span>IDL<\/h3>\n

\u00a0<\/span><\/p>\n

import “oaidl.idl”;<\/span><\/p>\n

import “ocidl.idl”;<\/span><\/p>\n

\u00a0<\/span><\/p>\n

[<\/span><\/p>\n

object,<\/p>\n

uuid(5E9396EC-ECA4-45F7-BEB1-EC56C381248A),<\/p>\n

helpstring(“IAny Interface”),<\/p>\n

pointer_default(unique)<\/p>\n

]<\/span><\/p>\n

interface IAny : IUnknown<\/span><\/p>\n

{<\/span><\/p>\n

\/\/ Passing info from client to server<\/p>\n

[helpstring(“method PShortsClientAlloc”)]<\/p>\n

HRESULT PassIn<\/span><\/strong>(<\/p>\n

[in]<\/span><\/strong> short count,<\/p>\n

[in, size_is(count)]<\/span><\/strong> short *<\/span><\/strong> pShort);<\/p>\n

\u00a0<\/span><\/p>\n

\/\/ Passing info from server to client<\/p>\n

[helpstring(“method GShortsServerAlloc”)]<\/p>\n

HRESULT PassOut<\/span><\/strong>(<\/p>\n

[out]<\/span><\/strong> short *<\/span><\/strong> pCount,<\/p>\n

[out, size_is(1, *pCount)]<\/span><\/strong> short **<\/span><\/strong> ppShort);<\/p>\n

\u00a0<\/span><\/p>\n

\/\/ passing info bidirectionally<\/p>\n

[helpstring(“method PassArray”)]<\/p>\n

HRESULT PassBirect<\/span><\/strong>(<\/p>\n

[in, out]<\/span><\/strong> short *<\/span><\/strong> psSize,<\/p>\n

[in, out, size_is(1, *psSize)]<\/span><\/strong><\/p>\n

short **<\/span><\/strong> pps);<\/p>\n

<\/strong>};<\/span><\/p>\n

\u00a0<\/span><\/p>\n

[<\/span><\/p>\n

uuid(BA65DD03-CEBC-4E7A-A968-033C1C542FB7),<\/p>\n

version(1.0),<\/p>\n

helpstring(“Server 1.0 Type Library”)<\/p>\n

]<\/span><\/p>\n

library SERVERLib<\/span><\/p>\n

{<\/span><\/p>\n

importlib(“stdole32.tlb”);<\/p>\n

importlib(“stdole2.tlb”);<\/p>\n

\u00a0<\/span><\/p>\n

[<\/span><\/p>\n

uuid(963BC191-1265-4E90-A330-13787BCA9437),<\/p>\n

helpstring(“Any Class”)<\/p>\n

]<\/span><\/p>\n

coclass Any<\/p>\n

{<\/span><\/p>\n

[default] interface IAny;<\/p>\n

};<\/span><\/p>\n

};<\/span><\/p>\n

\u00a8\u00a0\u00a0\u00a0 <\/span><\/span><\/span>Server<\/h3>\n

implementation<\/p>\n

\u00a0<\/span><\/p>\n

STDMETHODIMP CAny::PassIn<\/span><\/strong>(short count, short * pShort)<\/span><\/p>\n

{<\/span><\/p>\n

char buf[80];<\/p>\n

for(short i = 0; i < count; i++)<\/p>\n

{<\/span><\/p>\n

sprintf(buf, “Passed from client: %d”, pShort[i]);<\/p>\n

if((i % 1000) == 0)<\/p>\n

::MessageBox(NULL, buf, “Server”, MB_OK);<\/p>\n

}<\/span><\/p>\n

return S_OK;<\/p>\n

}<\/span><\/p>\n

\u00a0<\/span><\/p>\n

STDMETHODIMP CAny::PassOut<\/span><\/strong>(short * pCount, short ** ppShort)<\/span><\/p>\n

{<\/span><\/p>\n

short sSize = 10;<\/p>\n

(*pCount) = 10;<\/p>\n

(*ppShort) = (short *)CoTaskMemAlloc<\/span><\/strong>(sSize<\/p>\n

* sizeof(short));<\/p>\n

if((*ppShort) == NULL)<\/p>\n

return E_OUTOFMEMORY;<\/p>\n

for(short i = 0; i < sSize; i++)<\/p>\n

(*ppShort)[i] = i;<\/p>\n

\u00a0<\/span><\/p>\n

return S_OK;<\/p>\n

}<\/span><\/p>\n

\u00a0<\/span><\/p>\n

STDMETHODIMP CAny::PassBidirect<\/span><\/strong>(short * pSize, short **pps)<\/span><\/p>\n

{<\/span><\/p>\n

char buf[80];<\/p>\n

for(short i = 0; i < *pSize<\/span><\/strong>;<\/p>\n

i++)<\/p>\n

{<\/span><\/p>\n

sprintf(buf, “Passed from<\/span><\/p>\n

client:\\n*pps[%d] = %d”, i, (*pps)<\/span><\/strong>[i]);<\/p>\n

::MessageBox(NULL, buf, “Server”, MB_OK);<\/p>\n

}<\/span><\/p>\n

\u00a0<\/span><\/p>\n

CoTaskMemFree<\/span><\/strong>(*pps);<\/span><\/p>\n

short sSize = 10;<\/p>\n

(*pps)<\/span><\/strong> = (short *)CoTaskMemAlloc<\/span><\/strong>(sSize<\/span><\/p>\n

* sizeof(short));<\/p>\n

for(i = 0; i < sSize; i++)<\/p>\n

{<\/span><\/p>\n

(*pps)<\/span><\/strong>[i] = i * i;<\/p>\n

}<\/span><\/p>\n

(*pSize)<\/span><\/strong> = sSize;<\/span><\/p>\n

return S_OK;<\/p>\n

}<\/span><\/p>\n

\u00a8\u00a0\u00a0\u00a0 <\/span><\/span><\/span>Client<\/h3>\n

implementation<\/p>\n

\u00a0<\/span><\/p>\n

void CClientDlg::OnPassIn() <\/span><\/p>\n

{<\/span><\/p>\n

const short sSize = 7001;<\/p>\n

short * pShort;<\/p>\n

pShort = (short *)CoTaskMemAlloc<\/span><\/strong>(sSize<\/p>\n

* sizeof(short));<\/p>\n

if(pShort == NULL)<\/p>\n

{<\/span><\/p>\n

::MessageBox(NULL, “CoTaskMemAlloc failed!”,<\/p>\n

“Client”, MB_OK);<\/p>\n

return;<\/p>\n

}<\/span><\/p>\n

\u00a0<\/span><\/p>\n

for(short i = 0; i < sSize; i++)<\/p>\n

pShort[i] = i;<\/p>\n

\u00a0<\/span><\/p>\n

HRESULT hr = m_pAny->PassIn<\/span><\/strong>(sSize,<\/p>\n

pShort);<\/p>\n

if(FAILED(hr))<\/p>\n

::MessageBox(NULL, “PassShorts<\/span><\/p>\n

failed!”, “Client”, MB_OK);<\/p>\n

\u00a0<\/span><\/p>\n

CoTaskMemFree<\/span><\/strong>(pShort);<\/span><\/p>\n

}<\/span><\/p>\n

\u00a0<\/span><\/p>\n

void CClientDlg::OnPassOut() <\/span><\/p>\n

{<\/span><\/p>\n

short sSize;<\/p>\n

short * pShort = NULL<\/span><\/strong>;<\/span><\/p>\n

\u00a0<\/span><\/p>\n

HRESULT hr = m_pAny->PassOut<\/span><\/strong>(&sSize,<\/p>\n

&pShort);<\/p>\n

if(FAILED(hr))<\/p>\n

::MessageBox(NULL, “PShortsServerAlloc failed!”,<\/p>\n

“Client”, MB_OK);<\/p>\n

\u00a0<\/span><\/p>\n

char buf[80];<\/p>\n

for(short i = 0; i < sSize; i++)<\/p>\n

{<\/span><\/p>\n

sprintf(buf, “Got from server: %d”, pShort[i]);<\/p>\n

if((i % 1000) == 0)<\/p>\n

::MessageBox(NULL, buf, “Client”, MB_OK);<\/p>\n

}<\/span><\/p>\n

\u00a0<\/span><\/p>\n

CoTaskMemFree<\/span><\/strong>(pShort);<\/span><\/p>\n

}<\/span><\/p>\n

\u00a0<\/span><\/p>\n

void CClientDlg::OnPassBidirect<\/span><\/strong>()<\/span><\/p>\n

 <\/p>\n

{<\/span><\/p>\n

sSize = 5;<\/p>\n

short * ps = (short *)CoTaskMemAlloc<\/span><\/strong>(sSize<\/p>\n

* sizeof(short));<\/p>\n

for(i = 0; i < sSize; i++)<\/p>\n

ps[i] = i;<\/p>\n

\u00a0<\/span><\/p>\n

hr<\/span><\/p>\n

= pAny->PassBidirect<\/span><\/strong>(&sSize,<\/p>\n

&ps);<\/p>\n

if(FAILED(hr))<\/span><\/p>\n

{<\/span><\/p>\n

::MessageBox(NULL, “PassArray failed!”, “Client”,<\/p>\n

MB_OK);<\/p>\n

return FALSE;<\/p>\n

}<\/span><\/p>\n

\u00a0<\/span><\/p>\n

char buf[80];<\/p>\n

for(i = 0; i < sSize; i++)<\/p>\n

{<\/span><\/p>\n

sprintf(buf, “Passed from client:\\nps[%d] = %d”, i, ps[i]);<\/p>\n

::MessageBox(NULL, buf, “Server”, MB_OK);<\/p>\n

}<\/span><\/p>\n

CoTaskMemFree<\/span><\/strong>(ps);<\/span><\/p>\n

}<\/span><\/p>\n

<\/a><\/a><\/a>6.5.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>Example of Passing Variable-Length Custom Types<\/span><\/span><\/h2>\n

\u00a8\u00a0\u00a0\u00a0 <\/span><\/span><\/span>IDL<\/h3>\n

\u00a0<\/span><\/p>\n

import<\/span><\/p>\n

“oaidl.idl”;<\/p>\n

import<\/span><\/p>\n

“ocidl.idl”;<\/p>\n

\u00a0<\/span><\/p>\n

typedef struct {<\/span><\/p>\n

short sSize;<\/span><\/p>\n

[size_is(sSize)]<\/span><\/strong><\/span><\/p>\n

short sArray[]<\/span><\/strong>;<\/p>\n

} Group<\/span><\/strong>;<\/span><\/p>\n

\u00a0<\/span><\/p>\n

\u00a0<\/span><\/p>\n

[<\/span><\/p>\n

object,<\/span><\/p>\n

uuid(9BF19302-65E6-4218-8C6F-55C3816123F5),<\/p>\n

helpstring(“IAny Interface”),<\/span><\/p>\n

pointer_default(unique)<\/span><\/p>\n

]<\/span><\/p>\n

interface IAny : IUnknown<\/span><\/p>\n

{<\/span><\/p>\n

[helpstring(“method StructInOut”)]<\/p>\n

<\/a>HRESULT<\/span><\/p>\n

StructInOut([in, out] Group ** ppg)<\/span><\/strong>;<\/p>\n

};<\/span><\/p>\n

\u00a0<\/span><\/p>\n

[<\/span><\/p>\n

uuid(185CB840-2F73-4095-A165-8FAFEDA1CBF8),<\/span><\/p>\n

version(1.0),<\/span><\/p>\n

helpstring(“Marshal 1.0 Type<\/span><\/p>\n

Library”)<\/p>\n

]<\/span><\/p>\n

library<\/span><\/p>\n

MARSHALLib<\/p>\n

{<\/span><\/p>\n

importlib(“stdole32.tlb”);<\/span><\/p>\n

importlib(“stdole2.tlb”);<\/span><\/p>\n

\u00a0<\/span><\/p>\n

[<\/span><\/p>\n

uuid(27FE57E8-26EF-4E41-AEB9-79DE4079F0E1),<\/span><\/p>\n

helpstring(“Any Class”)<\/span><\/p>\n

]<\/span><\/p>\n

coclass Any<\/span><\/p>\n

{<\/span><\/p>\n

[default] interface IAny;<\/span><\/p>\n

};<\/span><\/p>\n

};<\/span><\/p>\n

\u00a8\u00a0\u00a0\u00a0 <\/span><\/span><\/span>Server<\/h3>\n

implementation<\/p>\n

\u00a0<\/span><\/p>\n

STDMETHODIMP<\/span><\/p>\n

CAny::StructInOut<\/span><\/strong>(Group **ppg)<\/p>\n

{<\/span><\/p>\n

char buf[100];<\/span><\/p>\n

for(short i = 0; i < (*ppg)->sSize;<\/span><\/p>\n

i++)<\/p>\n

{<\/span><\/p>\n

sprintf(buf, “(*ppg)->sArray[%d] = %d”, i,<\/p>\n

(*ppg)->sArray[i]);<\/p>\n

M(buf); \/\/ Macro to simplify function<\/span><\/p>\n

::MessageBox<\/p>\n

}<\/span><\/p>\n

\u00a0<\/span><\/p>\n

\u00a0<\/span><\/p>\n

short sSize = 20;<\/span><\/p>\n

(*ppg) = (Group *)CoTaskMemAlloc<\/span><\/strong>(sSize * sizeof(short) +<\/span><\/p>\n

sizeof(Group));<\/p>\n

if((*ppg) == NULL) \/\/ must check the result<\/span><\/p>\n

of memory allocation<\/p>\n

{<\/span><\/p>\n

::MessageBox(NULL, “<\/span><\/p>\n

CoTaskMemAlloc failed!”, “Server”, MB_OK);<\/p>\n

return E_OUTOFMEMORY;<\/span><\/p>\n

}<\/span><\/p>\n

\u00a0<\/span><\/p>\n

(*ppg)->sSize = sSize;<\/span><\/p>\n

for (i = 0; i < (*ppg)->sSize; i++) <\/span><\/p>\n

(*ppg)->sArray[i] = i * i;<\/span><\/p>\n

\u00a0<\/span><\/p>\n

return S_OK;<\/span><\/p>\n

}<\/span><\/p>\n

\u00a8\u00a0\u00a0\u00a0 <\/span><\/span><\/span>Client<\/h3>\n

implementation<\/p>\n

\u00a0<\/span><\/p>\n

void<\/span><\/p>\n

CClientDlg::OnButton3()<\/p>\n

{<\/span><\/p>\n

short lSize = 5;<\/span><\/p>\n

Group * pg;<\/p>\n

pg = (Group *)CoTaskMemAlloc(lSize *<\/span><\/p>\n

sizeof(short) + sizeof(Group));<\/p>\n

if(pg == NULL)<\/span><\/p>\n

{<\/span><\/p>\n

M(“CoTaskMemAlloc failed!”);<\/span><\/p>\n

return;<\/span><\/p>\n

}<\/span><\/p>\n

pg->sSize = lSize;<\/span><\/p>\n

for(short i = 0; i < lSize; i++)<\/span><\/p>\n

pg->sArray[i] = i;<\/span><\/p>\n

\u00a0<\/span><\/p>\n

HRESULT hr = m_p->StructInOut<\/span><\/strong>(&pg);<\/span><\/p>\n

if(FAILED(hr))<\/span><\/p>\n

M(“StructInOut failed”);<\/span><\/p>\n

\u00a0<\/span><\/p>\n

char buf[100];<\/span><\/p>\n

for(i = 0; i < pg->sSize; i++)<\/span><\/p>\n

{<\/span><\/p>\n

sprintf(buf, “pg->sArray[%d] =<\/span><\/p>\n

%d”, i, pg->sArray[i]);<\/p>\n

M(buf);<\/span><\/p>\n

}<\/span><\/p>\n

\u00a0<\/span><\/p>\n

CoTaskMemFree<\/span><\/strong>(pg);<\/span><\/p>\n

}<\/span><\/p>\n

<\/a><\/a>6.6.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>Proxy\/StubClasses<\/span><\/h2>\n

A proxy resides in the client’s process and represents the<\/p>\n

server,and a stub resides in the<\/p>\n

server’s process to receive data sent from the proxy and send server’s response<\/p>\n

back. They are all standard COM objects residing in a DLL server. On such DLL<\/p>\n

server may contain many proxy\/stub classes.<\/p>\n

Each interface in a server is represented by a separate<\/p>\n

proxy and stub coclass. Each proxy coclass implements two interfaces: the one<\/p>\n

which it represents and a standard interface IRpcProxyBuffer<\/strong>, which has<\/p>\n

method Connect<\/strong> and Disconnect<\/strong>.<\/p>\n

Channel object implementing interface IRpcChannelBuffer<\/strong><\/p>\n

is responsible to conduct the data transfer between the proxy and the stub.<\/p>\n

Proxy manager is responsible to connect proxy objects to the channel object,<\/p>\n

and assemble the proxy objects representing different interfaces of one coclass<\/p>\n

together using COM aggregation, so that the cluster of proxy coclasses appears<\/p>\n

to the client as a cluster of interfaces of one coclass.<\/p>\n

A stub implements IRpcStubBuffer<\/strong> and is managed by<\/p>\n

the stub manager. Stub manager doesn’t aggregate the stubs.<\/p>\n

Class factories implement interface IPSFactoryBuffer<\/strong>.<\/p>\n

One class factory is responsible to create both the proxy and stub for a given<\/p>\n

server coclass with its method CreateProxy<\/strong> and CreateStub<\/strong>.<\/p>\n

<\/a><\/a>6.7.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>Marshalling Options<\/span><\/h2>\n

\u00a8\u00a0\u00a0\u00a0 <\/span><\/span><\/span>Custom<\/h3>\n

Marshalling<\/p>\n

If you choose to write all marshalling code yourself, you<\/p>\n

should let your coclass implement interface IMarshal<\/strong>. SCM will query for<\/p>\n

IMarshal first. This marshalling option is called custom marshalling.<\/p>\n

\u00a8\u00a0\u00a0\u00a0 <\/span><\/span><\/span>Standard<\/h3>\n

Marshalling<\/p>\n

This is an easier option. When MIDL compiles the IDL file it<\/p>\n

will generate all files that is needed to build the proxy\/stub DLL, such as Shape_i.c<\/strong>,<\/p>\n

Shape.h<\/strong>, Shape_p.c<\/strong> and dlldata.c<\/strong>. ATL AppWizard can<\/p>\n

generate a make file which can automatically build the proxy\/stub DLL from the<\/p>\n

above four files. To build the proxy\/stub DLL server and register it:<\/p>\n

\u00a0<\/span><\/p>\n

nmake ProjectNameps.mk <\/span><\/p>\n

regsvr32 ProjectNameps.dll<\/span><\/p>\n

You can put the last two commands in mene \u201cProject\u201d |<\/p>\n

\u201cSettings\u201d | \u201cCustom build\u201d. This way every time you build the project the rest<\/p>\n

is done automatically.<\/p>\n

When client invokes an interface, SCM will find the<\/p>\n

interface entry under HKCR\\Interface<\/strong>, then the ProxyStubClsid32<\/strong><\/p>\n

entry under it, which points to the corresponding custom proxy\/stub DLL. Then<\/p>\n

SCM will call the class factory and instantiate a proxy\/stub object to<\/p>\n

prepresent the interface.<\/p>\n

\u00a8\u00a0\u00a0\u00a0 <\/span><\/span><\/span>Universal<\/h3>\n

Marshalling<\/p>\n

The third option is to use the universal marshaller oleaut32.dll<\/strong>.<\/p>\n

The ProxyStubClsid32<\/strong> entries of all interfaces should point to this<\/p>\n

universal marshaller, and the TypeLib<\/strong> entries point to the registered<\/p>\n

type library. The universal marshaller will find the registered type library of<\/p>\n

the invoked interface, read the type information in it, and create the<\/p>\n

proxy\/stub DLL on the fly.<\/p>\n

To use universal marshaller, you have to:<\/p>\n

1.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span>Put<\/p>\n

attribute [oleautomation]<\/strong> in front of all interfaces and make them<\/p>\n

variant compatible;<\/p>\n

2.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span>Register<\/p>\n

the type library;<\/p>\n

3.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span>Register<\/p>\n

all interfaces and set the value of ProxyStubClsid32<\/strong> entry under each<\/p>\n

interface to the guid of oleaut32.dll<\/strong> and the value of TypeLib<\/strong><\/p>\n

entry to your type library guid.<\/p>\n

You can also do all the above things through a function call<\/p>\n

at run time:<\/p>\n

\u00a0<\/span><\/p>\n

ITypeLib * ptlb = NULL;<\/span><\/p>\n

LoadTypeLibEx<\/span><\/strong>(L\u201dShapes.tlb\u201d, REGKIND_REGISTER<\/span><\/strong>, &ptlb);<\/span><\/p>\n

ptlb->Release();<\/span><\/p>\n

If there is [oleautomation]<\/strong> attribute in front of all<\/p>\n

interfaces in the IDL file, this function will point the ProxyStubClsid32<\/strong><\/p>\n

entry to the universal marshaler.<\/p>\n

<\/a><\/a>6.8.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>Hosting an DLL in a Surrogate Process<\/span><\/h2>\n

To host a DLL in an EXE housing named dllhost.exe, you need<\/p>\n

to have an AppID for the DLL server and have a DllSurrogate<\/strong> entry under<\/p>\n

it. When its value is “”, it means that we use the default surrogate dllhost.exe<\/strong>.<\/p>\n

To automatically assign an AppID and add a DllSurrogate<\/strong><\/p>\n

entry under it, open the DLL object under “All Object” entry of<\/p>\n

OLE\/COM Object Viewer. Tick the “Use Surrogate Process” option. The<\/p>\n

COM objects in the DLL server must support aggregation.<\/p>\n

<\/a><\/a>7.\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h1>\n

 <\/p>\n

<\/a>DCOM<\/span><\/h1>\n

<\/a><\/a>7.1.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>Configuring a Server to be Invoked Remotely<\/span><\/h2>\n

There are three major issues to configure for a server to be<\/p>\n

invoked remotely. The first two can be configured machine-wide, so that you<\/p>\n

decide the settings for the machine, and all servers which has not been<\/p>\n

specifically configured take the machine-wide settings. All these things can be<\/p>\n

done through dcomcnfg.exe<\/strong>.<\/p>\n

\u00a8\u00a0\u00a0\u00a0 <\/span><\/span><\/span>Authentication<\/h3>\n

Level<\/p>\n

Determines how often and how strict does the COM run<\/p>\n

time check for the server the identification of the client.<\/p>\n

\u00a8\u00a0\u00a0\u00a0 <\/span><\/span><\/span>Security<\/h3>\n

Includes Access Permission, Launch Permission and<\/p>\n

Configuration Permission. Each server has an AppID to store server-wide<\/p>\n

attributes. In System Registry, each AppID has a Access Control List (ACL),<\/p>\n

which lists which client has which permssion.<\/p>\n

\u00a8\u00a0\u00a0\u00a0 <\/span><\/span><\/span>Server<\/h3>\n

Identify<\/p>\n

A server is launched with an user account identity. It has<\/p>\n

three options:<\/p>\n

1.\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/p>\n

The Interactive User: all servers in a machine<\/p>\n

are launched with the identity of the person who is logged on to this machine.<\/p>\n

This is only used in debugging session when you want the server to display some<\/p>\n

GUI such as a message box. If you do not choose this option the server can not<\/p>\n

display any GUI on the machine and will appear pending.<\/p>\n

2.\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/p>\n

The Launching User: the server always has the<\/p>\n

identify of the person who launched it. As a side effect, the SCM will launch a<\/p>\n

new instance of the server for each client.<\/p>\n

3.\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/p>\n

This User: proper for production application.<\/p>\n

You select one or a group of users as the identity of the server.<\/p>\n

<\/a><\/a>7.2.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>Configuring a Client to Call Remote Server<\/span><\/h2>\n

The server should be registered on the client machine. You<\/p>\n

can configure the client to call remote server with dcomcnfg.exe<\/strong>. Choose<\/p>\n

a server and double-click it to bring up the properties of the server. In the<\/p>\n

“Location” tab, choose correct option. You can tick either or both of<\/p>\n

the options: “Run application on this computer” or “Ran<\/p>\n

application on the following computer”, and enter the name of the remote<\/p>\n

computer. If you choose both, the SCM will choose the nearest one. The name of<\/p>\n

the computer will be assigned to a new entry RemoteServerName<\/strong> under HKCR\\AppID<\/strong>.<\/p>\n

When SCM sees this entry, it knows that it’s going remote.<\/p>\n

You can also configure a client through function CoCreateInstanceEx<\/strong>.<\/p>\n

It will suppress the dcomcnfg.exe<\/strong> settings:<\/p>\n

\u00a0<\/span><\/p>\n

COSERVERINFO<\/span><\/strong> serverInfo = {0};<\/span><\/p>\n

serverInfo.pwszName = L”FLIU”;<\/span><\/p>\n

\u00a0<\/span><\/p>\n

MULTI_QI<\/span><\/strong> interfaces[2] = {0};<\/span><\/p>\n

interfaces[0].pIID = &IID_IFirst;<\/span><\/p>\n

interfaces[1}.pIID = &IID_ISecond;<\/span><\/p>\n

\u00a0<\/span><\/p>\n

<\/a>CoCreateInstanceEx<\/span><\/strong>(<\/span><\/p>\n

CLSID_MyClass,<\/p>\n

NULL,<\/p>\n

CLSCTX_REMOTE_SERVER,<\/p>\n

&serverInfo,<\/p>\n

2,\/\/ Size of the MULTI_QI array<\/p>\n

interfaces);<\/p>\n

\u00a0<\/span><\/p>\n

if(FAILED(interfaces[0].hr))<\/span><\/p>\n

{<\/span><\/p>\n

::MessageBox(NULL, “Query for IID_IFirst failed!”,<\/p>\n

“Client”, MB_OK);<\/p>\n

return;<\/p>\n

}<\/span><\/p>\n

else if(FAILED(interfaces[1].hr))<\/span><\/p>\n

{<\/span><\/p>\n

::MessageBox(NULL, “Query for IID_IFirst failed!”,<\/p>\n

“Client”, MB_OK);<\/p>\n

return;<\/p>\n

}<\/span><\/p>\n

\u00a0<\/span><\/p>\n

IFirst * pf = (IFirst *)interfaces[0].pItf;<\/span><\/p>\n

ISecond * ps = (ISecond *)interfaces[1].pItf;<\/span><\/p>\n

…<\/span><\/p>\n

To be able to call the DOM functions in COM library such as CoInitialize,<\/strong><\/p>\n

CoInitializeEx<\/strong> or CoCreateInstanceEx<\/strong>, you should put the<\/p>\n

following line before including <windows.h> or in the project-wide<\/p>\n

#define settings:<\/p>\n

\u00a0<\/span><\/p>\n

#define _WIN32_DCOM<\/span><\/strong><\/span><\/p>\n

Function CoCreateInstanceEx<\/strong> uses two structures:<\/p>\n

\u00a0<\/span><\/p>\n

<\/a>WINOLEAPI CoCreateInstanceEx<\/span><\/strong>(<\/span><\/p>\n

REFCLSID Clsid,<\/p>\n

IUnknown * punkOuter,\/\/<\/p>\n

only relevant locally. Normally NULL<\/p>\n

DWORD dwClsCtx,\/\/<\/p>\n

CLSCTX<\/p>\n

COSERVERINFO * pServerInfo,\/\/<\/p>\n

contains server computer name<\/p>\n

DWORD dwCount,\/\/<\/p>\n

size of MULTI_QI array<\/p>\n

MULTI_QI * pResults );\/\/<\/p>\n

array of MULTI_QI<\/p>\n

Structure COSERVERINFO<\/strong> holds the server computer<\/p>\n

name:<\/p>\n

\u00a0<\/span><\/p>\n

typedef struct_COSERVERINFO<\/span><\/p>\n

{<\/span><\/p>\n

DWORD dwReserved1;<\/p>\n

<\/a>LPWSTR pwszName;<\/span><\/strong><\/p>\n

COAUTHINFO __RPC_FAR *pAuthInfo;<\/span><\/p>\n

DWORD dwReserved2;<\/p>\n

} COSERVERINFO<\/span><\/strong>;<\/span><\/p>\n

The array of structure MULTI_QI<\/strong> hold the IIDs of the<\/p>\n

wanted interfaces, the returned IUnknown pointers and HRESULTs:<\/p>\n

\u00a0<\/span><\/p>\n

typedef structtagMULTI_QI<\/span><\/p>\n

{<\/span><\/p>\n

const IID<\/span><\/strong> __RPC_FAR *pIID;<\/span><\/p>\n

IUnknown<\/span><\/strong> __RPC_FAR *pItf;<\/span><\/p>\n

<\/a>HRESULT hr<\/span><\/strong>;<\/span><\/p>\n

} MULTI_QI<\/span><\/strong>;<\/span><\/p>\n

<\/a><\/a>8.\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h1>\n

 <\/p>\n

<\/a>ATL Basics<\/span><\/h1>\n

<\/a><\/a>8.1.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>ATL Macro STDMETHOD & STDMETHODIMP<\/span><\/h2>\n

ATL uses macro STDMETHOD to define a method. It is defined<\/p>\n

as:<\/p>\n

\u00a0<\/span><\/p>\n

#define STDMETHOD(method)virtual HRESULT STDMETHODCALLTYPE method<\/span><\/p>\n

#define STDMETHODCALLTYPE__stdcall<\/span><\/p>\n

Therefore,<\/p>\n

\u00a0<\/span><\/p>\n

STDMETHOD(Calculate)(int x, float y)<\/span><\/p>\n

is in fact<\/p>\n

\u00a0<\/span><\/p>\n

virtual RESULT __stdcall<\/span><\/strong> Calculate(int x, float y)<\/span><\/p>\n

STDMETHODIMP is used to mark the implementation of a method.<\/p>\n

It is defined as:<\/p>\n

\u00a0<\/span><\/p>\n

#define STDMETHODIMPHRESULT STDMETHODCALLTYPE<\/span><\/p>\n

<\/a><\/a>8.2.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>Creating DLL Server with ATL<\/span><\/h2>\n

\u00a8\u00a0\u00a0\u00a0 <\/span><\/span><\/span>1.Create a project<\/h3>\n

In AppWizard, choose ATL COM AppWizard and DLL<\/p>\n

option. It will create those entry points for the project. No coclass is<\/p>\n

generated yet.<\/p>\n

\u00a8\u00a0\u00a0\u00a0 <\/span><\/span><\/span>2.Add a coclass<\/h3>\n

Choose \u201cInsert\u201d | \u201cNew ATL Object\u201d. Give the short name<\/p>\n

\u201cAccount\u201d. MFC will create a coclass with the initial default interface. The<\/p>\n

class name will be CAccount, coclass name Account, interface name IAccount.<\/p>\n

\u00a8\u00a0\u00a0\u00a0 <\/span><\/span><\/span>3.Add methods to the interface<\/h3>\n

Right-click the interface symbol e.g. IGreet under the class<\/p>\n

name CAccount. The dialog prompt out will be different from normal classes.<\/p>\n

Return type is by default HRESULT<\/strong>, and any parameter should start with [in]<\/strong><\/p>\n

or [out]<\/strong> indicating whether this parameter is to pass info into or out<\/p>\n

of the COM, such as \u201c[in] int amount\u201d or \u201c[out] int * balance\u201d.<\/p>\n

\u00a8\u00a0\u00a0\u00a0 <\/span><\/span><\/span>4.Add data members to the coclass<\/h3>\n

\u00a8\u00a0\u00a0\u00a0 <\/span><\/span><\/span>5.Implement the methods<\/h3>\n

The skeletons of the methods have already been set up by the<\/p>\n

wizard.<\/p>\n

\u00a8\u00a0\u00a0\u00a0 <\/span><\/span><\/span>6.Add more interfaces<\/h3>\n

Add the definition of a new interface into the ProjectName.IDL<\/strong><\/p>\n

file, such as<\/p>\n

\u00a0<\/span><\/p>\n

[<\/span><\/p>\n

object,<\/p>\n

uuid(0D6380A1-9FC8-4897-9621-47EFE50C8887),<\/p>\n

helpstring(“IDisplay Interface”),<\/p>\n

pointer_default(unique)<\/span><\/p>\n

]<\/span><\/p>\n

interface IDisplay : IUnknown<\/span><\/p>\n

{<\/span><\/p>\n

[helpstring(“method Show”)] HRESULT Show();<\/p>\n

};<\/span><\/p>\n

You need to generate the guid with \u201cMicrosoft Visual<\/p>\n

Studio\\Common\\Tools\\Guidgen.exe<\/strong>\u201d.<\/p>\n

Also add the interface name to the coclass definition in<\/p>\n

this IDL file.<\/p>\n

\u00a8\u00a0\u00a0\u00a0 <\/span><\/span><\/span>7.Modify coclass definition for additional<\/h3>\n

interfaces<\/p>\n

Let the coclass inherit from the new interfaces too. Add the<\/p>\n

COM_INTERFACE_ENTRY<\/strong> for the new interfaces in the COM_MAP<\/strong>.<\/p>\n

\u00a8\u00a0\u00a0\u00a0 <\/span><\/span><\/span>8.Repeat step 3 ~ 6<\/h3>\n

<\/a><\/a>8.3.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>Manually Registering ATL DLL Servers<\/span><\/h2>\n

A DLL COM server is<\/p>\n

supposed to export DllRegisterServer<\/strong> and DllUnregisterServer<\/strong> to<\/p>\n

register and unregister the server. You can invoke these functions using tool regsvr32.exe<\/strong>.<\/p>\n

To register a DLL server:<\/p>\n

\u00a0<\/span><\/p>\n

regsvr32 path\\bank.dll<\/span><\/p>\n

To unregister a DLL server:<\/p>\n

\u00a0<\/span><\/p>\n

regsvr32 \/u<\/span><\/strong><\/span><\/p>\n

path\\bank.dll<\/p>\n

ATL makes it even more convenient: it inserts the following<\/p>\n

lines into the menu \u201cProject\u201d | \u201cSettings\u201d | \u201cCustom Build\u201d option:<\/p>\n

\u00a0<\/span><\/p>\n

regsvr32 \/s \/c “$(TargetPath)” <\/span><\/p>\n

echo regsvr32 exec. time ><\/span><\/p>\n

“$(OutDir)\\regsvr32.trg”<\/p>\n

So that after each build the server will be automatically<\/p>\n

registered.<\/p>\n

<\/a><\/a>8.4.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>Supporting MFC in ATL Project<\/span><\/h2>\n

When creating a new DLL ATL project with ATL COM AppWizard,<\/p>\n

you can tick the “Support MFC” option. But this binds your code with<\/p>\n

MFC and you have to ship the MFC runtime dll is shipped with your product. So<\/p>\n

you should always try not to select this option.<\/p>\n

If you create an EXE ATL project, the “Support<\/p>\n

MFC” option is disabled. You have to add MFC support yourself.<\/p>\n

<\/a><\/a>8.5.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>Creating EXE Server with ATL<\/span><\/h2>\n

1.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/p>\n

Create an EXE server project with ATL COM<\/p>\n

AppWizard;<\/p>\n

2.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/p>\n

Add an ATL object;<\/p>\n

3.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/p>\n

Add methods to the primary interface of the ATL<\/p>\n

object;<\/p>\n

4.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/p>\n

Add more interfaces and methods in the same way<\/p>\n

as with DLL server;<\/p>\n

5.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/p>\n

Add the commands to make and register the<\/p>\n

proxy\/stub DLL into custom build;<\/p>\n

6.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/p>\n

Build the project.<\/p>\n

<\/a><\/a>8.6.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>Manually Registering ATL EXE Servers<\/span><\/h2>\n

Just like a DLL server, an EXE server also supports self<\/p>\n

registration. Simply run the program with command line argument \u201c\/RegServer<\/strong>\u201d<\/p>\n

to register or \u201c\/UnregServer<\/strong>\u201d to unregister:<\/p>\n

\u00a0<\/span><\/p>\n

<\/a>ProjectName \/RegServer<\/span><\/p>\n

<\/a><\/a>8.7.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>Removing an ATL Coclass<\/span><\/h2>\n

You can use ATL Object Wizard to insert new colcasses into<\/p>\n

the server, but to remove one added with ATL, you have to do the following<\/p>\n

things manually:<\/p>\n

1.\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/p>\n

In coclass.cpp, remove the #include of the<\/p>\n

coclass.h file;<\/p>\n

2.\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/p>\n

In coclass.cpp, remove the OBJECT_ENTRY<\/strong><\/p>\n

of the coclass;<\/p>\n

3.\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/p>\n

Remove the code in IDL file;<\/p>\n

4.\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/p>\n

Open the project’s *.rc file with Wordpad or<\/p>\n

Notepad, locate the section beginning with “\/\/REGISTRY”, and remove<\/p>\n

the line containing the coclass.rgs.<\/p>\n

5.\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/p>\n

Remove the *.cpp, *.h and *.rgs files of the<\/p>\n

coclass.<\/p>\n

8.8.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a><\/a>Implementing<\/span><\/h2>\n

an Interface in ATL<\/p>\n

<\/a><\/h2>\n

To implement an interface defined<\/p>\n

in the project’s IDL file, you have to<\/p>\n

1.\u00a0\u00a0\u00a0 <\/span><\/span><\/span>In<\/p>\n

the *.h file, let your coclass inherit from the interface,<\/p>\n

2.\u00a0\u00a0\u00a0 <\/span><\/span><\/span>In<\/p>\n

the *.h file, add an interface entry in the COM map,<\/p>\n

3.\u00a0\u00a0\u00a0 <\/span><\/span><\/span>In<\/p>\n

the *.h file, add the protoptypes of the interface methods:<\/p>\n

4.\u00a0\u00a0\u00a0 <\/span><\/span><\/span>In<\/p>\n

the *.cpp file, implement the methods of the interface.<\/p>\n

\u00a0<\/span><\/p>\n

\/\/**************** Any.h ********************<\/span><\/p>\n

class ATL_NO_VTABLE CAny : <\/span><\/p>\n

public CComObjectRootEx<CComSingleThreadModel>,<\/p>\n

public CComCoClass<CAny, &CLSID_Any>,<\/p>\n

public IMyInterf\/\/ step 1<\/span><\/strong><\/p>\n

{<\/span><\/p>\n

public:<\/span><\/p>\n

CAny(){}<\/span><\/p>\n

\u00a0<\/span><\/p>\n

<\/a>DECLARE_REGISTRY_RESOURCEID(IDR_ANY)<\/span><\/p>\n

DECLARE_NOT_AGGREGATABLE(CAny)<\/span><\/p>\n

<\/a>DECLARE_PROTECT_FINAL_CONSTRUCT()<\/span><\/p>\n

\u00a0<\/span><\/p>\n

BEGIN_COM_MAP(CAny)<\/span><\/p>\n

<\/a>COM_INTERFACE_ENTRY(IMyInterf)\/\/ step 2<\/span><\/strong><\/p>\n

<\/a>END_COM_MAP()<\/span><\/p>\n

\u00a0<\/span><\/p>\n

public:<\/span><\/p>\n

<\/a>STDMETHOD(Hi)();\/\/<\/span><\/strong><\/p>\n

step 3<\/p>\n

};<\/span><\/p>\n

\u00a0<\/span><\/p>\n

\/\/************** Any.cpp ********************<\/span><\/p>\n

<\/a>STDMETHODIMP CAny::Hi()\/\/ step 4<\/span><\/strong><\/strong><\/p>\n

{<\/span><\/p>\n

return<\/span><\/p>\n

S_OK;<\/p>\n

}<\/span><\/p>\n

You can also do all the above four<\/p>\n

steps automatically with ATL’s “Implement Interface Wizard”.<\/p>\n

Right-click the coclass in the class view, choose “Implement Interface”<\/p>\n

option, tick the unimplemented interface listed. If you do not see it listed,<\/p>\n

you may have forgotten to compile the IDL file.<\/p>\n

To be able to implement an<\/p>\n

interface with the wizard through type library, that interface must have been<\/p>\n

added into one coclass. For some reason, a stand-alone interface won’t be<\/p>\n

displayed by the wizard.<\/p>\n

To implement an interface defined<\/p>\n

in another server, you only need to do one extra thing: #import<\/strong> the type<\/p>\n

library:<\/p>\n

\u00a0<\/span><\/p>\n

#import “D:\\My Documents\\Visual<\/span><\/p>\n

C++\\AnyServer\\AnyServer.tlb” \\<\/p>\n

raw_interfaces_only, raw_native_types,<\/span><\/p>\n

no_namespace, named_guids<\/p>\n

When you are using ATL’s<\/p>\n

“Implement Interface Wizard”, just click the “Add<\/p>\n

TypeLib…” button in the “Implement Interface” dialog. It will<\/p>\n

bring up another window containing all registered type libraries. If the type<\/p>\n

library is not yet registered, you can click the “Browse” button to<\/p>\n

browse to it. The wizard will add the #import line for you.<\/p>\n

<\/a><\/a>8.9.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>Debugging ATL Projects<\/span><\/h2>\n

For debug builds, macro ATLTRACE<\/strong> prints argument into<\/p>\n

the debug window:<\/p>\n

\u00a0<\/span><\/p>\n

LONG v = 1234;<\/span><\/p>\n

ATLTRACE(“The value is %d”, v);<\/span><\/p>\n

For release builds it expends to nothing.<\/p>\n

_ATL_DEBUG_QI<\/strong> preprocessor directive causes all QueryInterface<\/strong><\/p>\n

calls to be writtin into the debug window. Just put in stdafx.h<\/strong> the<\/p>\n

following line:<\/p>\n

\u00a0<\/span><\/p>\n

#define _ATL_DEBUG_QI<\/span><\/p>\n

To be able to see the interface call in form of<\/p>\n

“IAny”, “IMyInterface” instead of 128-bit guids, the<\/p>\n

interfaces should be registered.<\/p>\n

Preprocessor directive _ATL_DEBUG_INTERFACES<\/strong> is based<\/p>\n

on _ATL_DEBUG_QI<\/strong> and can display the reference count and detect<\/p>\n

mishandling of AddRef<\/strong> and Release<\/strong>.<\/p>\n

<\/a><\/a>9.\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h1>\n

 <\/p>\n

<\/a>COM Threading Issues<\/span><\/h1>\n

<\/a><\/a>9.1.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>Multiple Thread Synchronization With Critical<\/span><\/h2>\n

Section<\/p>\n

<\/a><\/h2>\n

In non-COm C++ environment, different threads in the same<\/p>\n

process can freely talk to each other. Objects that are exposed to multiple<\/p>\n

threads have to make all their data thread-safe if necessary.<\/p>\n

Following is a multithreaded example making use of CRITICAL_SECTION<\/strong><\/p>\n

to guarantee that a certain piece of code can only be accessed by one thread.<\/p>\n

The main thread creates a”ThreadParam” structureto hold parameters to pass to the new threads<\/p>\n

it fires. The parameters include a class object and a function pointer.<\/p>\n

\u00a0<\/span><\/p>\n

#include “stdafx.h”<\/span><\/p>\n

#include “iostream.h”<\/span><\/p>\n

#include <stdio.h><\/span><\/p>\n

\u00a0<\/span><\/p>\n

<\/a>CRITICAL_SECTION<\/span><\/strong> g_cs;<\/span><\/p>\n

\u00a0<\/span><\/p>\n

typedef void(* Function)(int);<\/span><\/p>\n

\u00a0<\/span><\/p>\n

typedef struct {<\/span><\/p>\n

int<\/span><\/p>\n

a;<\/p>\n

} Any<\/span><\/strong>;<\/span><\/p>\n

\u00a0<\/span><\/p>\n

typedef struct {<\/span><\/p>\n

Function f;<\/p>\n

Any<\/span><\/p>\n

* pAny;<\/p>\n

} ThreadParam<\/span><\/strong>;<\/span><\/p>\n

\u00a0<\/span><\/p>\n

void ShowNumber<\/span><\/strong>(int<\/span><\/p>\n

a)<\/p>\n

{<\/span><\/p>\n

char buf[80];<\/p>\n

sprintf(buf, “Number = %d”, a);<\/p>\n

m(buf);<\/p>\n

}<\/span><\/p>\n

\u00a0<\/span><\/p>\n

\/\/ Global thread function with arbitrary name<\/span><\/p>\n

but standard signature<\/p>\n

DWORD WINAPI Threads(void * p)<\/span><\/p>\n

{<\/span><\/p>\n

<\/a>EnterCriticalSection<\/span><\/strong>(&g_cs);<\/span><\/p>\n

\u00a0<\/span><\/p>\n

ThreadParam * pThreadParam = (ThreadParam *)p;<\/p>\n

char buf[80];<\/p>\n

sprintf(buf, “Beginning of thread %d”,<\/p>\n

(pThreadParam->pAny)->a);<\/p>\n

m(buf);<\/p>\n

Any<\/span><\/p>\n

* pAny = pThreadParam->pAny;<\/p>\n

Function f = pThreadParam->f;<\/p>\n

f(pAny->a);<\/p>\n

\u00a0<\/span><\/p>\n

sprintf(buf, “End of thread %d”,<\/p>\n

(pThreadParam->pAny)->a);<\/p>\n

m(buf);<\/p>\n

delete pThreadParam->pAny;<\/p>\n

delete pThreadParam;<\/p>\n

\u00a0<\/span><\/p>\n

LeaveCriticalSection<\/span><\/strong>(&g_cs);<\/span><\/p>\n

return 0;<\/p>\n

}<\/span><\/p>\n

\u00a0<\/span><\/p>\n

int APIENTRY WinMain(HINSTANCE hInstance,<\/span><\/p>\n

HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)<\/p>\n

{<\/span><\/p>\n

InitializeCriticalSection<\/span><\/strong>(&g_cs);<\/span><\/p>\n

ThreadParam * pThreadParam;<\/p>\n

\u00a0<\/span><\/p>\n

for (int i = 1; i < 10; i++)<\/p>\n

{<\/span><\/p>\n

pThreadParam = new ThreadParam;<\/p>\n

pThreadParam->pAny = new Any;<\/span><\/p>\n

pThreadParam->f = ShowNumber;<\/p>\n

pThreadParam->pAny->a = i;<\/p>\n

\u00a0<\/span><\/p>\n

DWORD dw;<\/p>\n

HANDLE h = CreateThread<\/span><\/strong><\/p>\n

(NULL, 0, Threads, (void *)pThreadParam, 0, &dw);<\/p>\n

CloseHandle(h);<\/p>\n

}<\/span><\/p>\n

\u00a0<\/span><\/p>\n

Sleep(20000);<\/span><\/p>\n

DeleteCriticalSection<\/span><\/strong>(&g_cs);<\/span><\/p>\n

return 0;<\/p>\n

}<\/span><\/p>\n

<\/a><\/a>9.2.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>COM Apartments<\/span><\/h2>\n

When a thread calls CoInitializeEx<\/strong> (CoInitialize<\/strong><\/p>\n

maps to CoInitializeEx<\/strong>), it creates a COM apartment. If the second<\/p>\n

parameter of the function call is COINIT_APARTMENTTHREADED<\/strong>, a new<\/p>\n

Single-threaded Apartment (STA) is created. If it is COINIT_MULTITHREADED<\/strong>,<\/p>\n

the thread either creates a Multithreaded Apartment (MTA) if there isn\u2019t one<\/p>\n

created, or enters an existing one. So there can be multiple STAs in a process,<\/p>\n

but there is only one MTA per process.<\/p>\n

CoInitializeEx<\/strong> Initializes the COM library for use by<\/p>\n

the calling thread, sets the thread’s concurrency model, and creates a new<\/p>\n

apartment for the thread if one is required [MSDN]. A thread must call CoInitializeEx<\/strong><\/p>\n

before calling any other COM library function except CoGetMalloc<\/strong> and<\/p>\n

other memory allocation functions.<\/p>\n

When this thread calls CoCreateInstance<\/strong>, depending on<\/p>\n

whether the component\u2019s apartment type is the same, it either loads the<\/p>\n

component in the same apartment, or in a different one.<\/p>\n

Accesses to a coclass in an EXE server through<\/p>\n

proxy\/stub marshallers are automatically serialized, so there is no multithread<\/p>\n

synchronization issue when multiple clients are invoking the same EXE server.<\/p>\n

But different threads in a process can invoke concurrently the same DLL server.<\/p>\n

A component should never create any threads on its own. This<\/p>\n

is primarily of concern to J++ and C++ developers, who have the ability to<\/p>\n

create threads directly. Developers creating objects in Visual Basic do not need<\/p>\n

to worry about this, as there is no way for them to explicitly create a thread<\/p>\n

[MSDN].<\/p>\n

\u00a8\u00a0\u00a0\u00a0 <\/span><\/span><\/span>STA<\/h3>\n

and MTA<\/p>\n

If one thread creates an apartment and then dispatches<\/p>\n

another thread which also needs to call COM library functions, the new thread<\/p>\n

should also call CoInitializeEx<\/strong> itself to create or enter another<\/p>\n

apartment.<\/p>\n

If one STA thread wants to pass an interface pointer of a<\/p>\n

STA component to another STA thread, you must explicitly marshal the pointer,<\/p>\n

so that the calls to the component from the two threads are synchronized by the<\/p>\n

marshaller. Otherwise they won\u2019t be synchronized.<\/p>\n

However, if the thread(s) and the component are in different<\/p>\n

types of apartments, you don\u2019t need to explicitly marshal the pointer, because<\/p>\n

proxy and stub will be loaded for inter-apartment calls and they will<\/p>\n

synchroniz all calls.<\/p>\n

If you are passing pointer to a MTA component between MTA<\/p>\n

threads, don\u2019t marshal it, because a MTA component is meant to be accessed<\/p>\n

concurrently by multiple threads.<\/p>\n

If we follow the above rule, we can make sure that one<\/p>\n

instance in a STA can only be accessed by one thread at the same time. However,<\/p>\n

two STA threads can access two instances of the same coclass concurrently,<\/p>\n

therefore they can access the same global or class data concurrently. So STA<\/p>\n

components must protect their global and class data. Local objects must be<\/p>\n

allocated on the stack.<\/p>\n

If DllGetClassObject<\/strong> creates one class factory<\/p>\n

instance for each client request, the class factory does not need to be<\/p>\n

thread-safe. If a component uses one class factory instance for all client<\/p>\n

requests, then it needs to be thread-safe.<\/p>\n

Becaue of the synchronization, the performance of a STA<\/p>\n

component is lower than a MTA component.<\/p>\n

Because multiple threads can execute in an MTA concurrently,<\/p>\n

so you must protect all data in your component if necessary using critical<\/p>\n

sections or similar measures.<\/p>\n

\u00a8\u00a0\u00a0\u00a0 <\/span><\/span><\/span>Primary<\/h3>\n

STA<\/p>\n

Early legacy COM components are designed to be used in<\/p>\n

single-threaded environment. Their data is not protected at all. They also<\/p>\n

don’t put ThreadingModel<\/strong> entry into the System Registry.<\/p>\n

When COM is asked to create an instance of coclass which<\/p>\n

doesn’t have a ThreadingModel<\/strong> entry, it will always put the instance in<\/p>\n

the first STA apartment. Therefore all legacy components are placed in the same<\/p>\n

STA apartment.It means that if one<\/p>\n

thread is calling any method in any componet in that STA, all other threads<\/p>\n

which wants to invoke any component have to wait. Therefore these components<\/p>\n

are 100% thread safe, including their global and class data. But there<\/p>\n

performance is the worst.<\/p>\n

\u00a8\u00a0\u00a0\u00a0 <\/span><\/span><\/span>Confusion<\/h3>\n

Now that calls between STA and MTA are synchronized by<\/p>\n

proxy\/stub, and calls from two STA threads to a STA component has to be<\/p>\n

synchronized manually, what\u2019s the use of STA\u2019s message pump?<\/p>\n

<\/a><\/a>9.3.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>How do Components Declare Their Threading Model<\/span><\/h2>\n

When a coclass registers itself with *.rgs file in<\/p>\n

the system registery, it can register itself as one of four threading model by<\/p>\n

adding (or not adding) a ThreadingModel<\/strong> entry under HKCR\\CLSID\\<clsid>\\InprocServer32<\/strong>:<\/p>\n

1.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/p>\n

Primary STAno<\/p>\n

ThreadingModel entry,<\/p>\n

2.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/p>\n

STAThreadingModel<\/p>\n

= “Apartment”,<\/p>\n

3.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/p>\n

MTAThreadingModel<\/p>\n

= “Free”,<\/p>\n

4.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/p>\n

BothThreadingModel<\/p>\n

= “Both”,<\/p>\n

When you create a coclass (not a DLL or EXE housing) using<\/p>\n

ATL COM Wizard, you will be offered a chance to select from the above four<\/p>\n

options. Then the wizard will automatically generate a rgs file containing the<\/p>\n

correct registry entry.<\/p>\n

Note that although a coclass can be dealt with by COM run<\/p>\n

time in the above four different ways, the coclass itself can be implemented in<\/p>\n

only two ways: STA or MTA. When using ATL it is determined by inheriting from<\/p>\n

template class CComObjectRootEx<CComSingleThreadModel><\/strong> or CComObjectRootEx<CComMultiThreadModel><\/strong>.<\/p>\n

Especially, if you choose “Both” option, your<\/p>\n

component must aggregate with the free-threaded marshaller provided by COM. To<\/p>\n

do it, tick the “Free-threaded marshaller” option when you create an<\/p>\n

ATL object with the ATL Object Wizard.<\/p>\n

<\/a><\/a>9.4.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>How Does COM Choose Apartments for Components at<\/span><\/h2>\n

Run Time<\/p>\n

<\/a><\/h2>\n

A DLL coclass declares what kind of thread it can safely<\/p>\n

live in by putting a ThreadingModel<\/strong> entry in the System Registry.<\/p>\n

Before a client thread invokes a component, it must first<\/p>\n

create a new apartment (can be STA or MTA) or enter an existing apartment<\/p>\n

(MTA). Then when it asks COM run time to load a COM component, COM will compare<\/p>\n

the apartment type of the client and the component, to decide whether to load<\/p>\n

the component in the same apartment as the client and let the client directly<\/p>\n

access it, or create a new apartment for the component alone and let the client<\/p>\n

talk to the component through proxy\/stub marshallers, which is less efficient<\/p>\n

than the first option.<\/p>\n

To achieve better performance, COM run time will always try<\/p>\n

to load the component in the same apartment as the client. Only when the<\/p>\n

component declares that “I can only stay in xxx apartment” which is<\/p>\n

different from the apartment of the client, will COM create a new apartment for<\/p>\n

the component.<\/p>\n

If a component declares itself to be \u201cPrimary STA\u201d, then COM<\/p>\n

always loads it in primary STA. Unless the client thread is also in the primary<\/p>\n

STA, proxy access is needed.<\/p>\n

If a component is \u201cSTA\u201d, and the client is in primary STA or<\/p>\n

a normal STA, COM will create the component instance in the same apartment as<\/p>\n

the client so that no proxy access is needed. If the client is in MTA, proxy<\/p>\n

access is needed.<\/p>\n

If a component is \u201cFree\u201d, and client is MTA, then the<\/p>\n

component is loaded into the process-unique MTA, and the client can directly<\/p>\n

access the component without any overhead. However, if client is<\/p>\n

single-threaded, then a proxy access is needed. This is not good.<\/p>\n

If a component is “Both”, then a directly access<\/p>\n

is always guaranteed, because COM always creates the component instance in the<\/p>\n

same apartment as the client, no matter the client is in primary STA, STA or<\/p>\n

MTA. This is the best component threading model, the cost is you have to<\/p>\n

provide full synchronization protection for your code.<\/p>\n

<\/a><\/a>9.5.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>Proxy\/stub<\/span><\/h2>\n

Any communication across the apartment boundary needs the<\/p>\n

help of a proxy\/stub DLL server, which is generated and registered with nmake<\/strong><\/p>\n

and regsvr32<\/strong> exactly as you do with EXE servers.<\/p>\n

<\/a><\/a>9.6.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>ATL’s Threading Support with<\/span><\/h2>\n

CComObjectRootEx<><\/p>\n

<\/a><\/h2>\n

ATL’s support for thread protection i.e. synchronization at<\/p>\n

the end comes to four methods: Increment<\/strong> and Decrement<\/strong> which are<\/p>\n

used to increment and decrement the object reference count m_refCount<\/strong>,<\/p>\n

and Lock<\/strong> and Unlock<\/strong> which wraps proected code and extends to<\/p>\n

critical section function calls.<\/p>\n

An ATL coclass always inherits from CComObjectRootEx<><\/strong>,<\/p>\n

which takes one threading model class as template parameter, which can either<\/p>\n

be CComSingleThreadModel<\/strong> (for STA coclass) or CComMultiThreadModel<\/strong><\/p>\n

(for MTA coclass).These two classes has<\/p>\n

exactly the same interfaces. They contain method Increment<\/strong> and Decrement<\/strong>,<\/p>\n

and the typedef<\/strong> of three other classes which contain method Lock<\/strong><\/p>\n

and Unlock<\/strong>.<\/p>\n

CComObjectRootEx<><\/strong> itself provides four thread<\/p>\n

protection methods: InternalAddRef<\/strong>, InternalRelease<\/strong>, Lock<\/strong>,<\/p>\n

Unlock<\/strong>, which all turn around and call methods of the passed threading<\/p>\n

model class to deal with threading issues. Method InternalAddRef<\/strong> and InternalReleas<\/strong>e<\/p>\n

are called by the CComObject<> <\/strong>template’s IUnknown method AddRef<\/strong><\/p>\n

and <\/strong>Release, and Lock <\/strong>and Unlock<\/strong> are used to enter and<\/p>\n

leave critical sections.<\/p>\n

InternalQueryInterface<\/strong> is provided elsewhere by CComObjectRootBase<\/strong>.<\/p>\n

\u00a0<\/span><\/p>\n

template <class ThreadModel<\/span><\/strong>><\/span><\/p>\n

class CComObjectRootEx<\/span><\/strong><\/span><\/p>\n

: public CComObjectRootBase<\/span><\/strong><\/p>\n

{<\/span><\/p>\n

public:<\/span><\/p>\n

typedef<\/span><\/strong> ThreadModel<\/span><\/strong><\/span><\/p>\n

_ThreadModel;<\/p>\n

typedef _ThreadModel::AutoCriticalSection _CritSec;<\/p>\n

typedef CComObjectLockT<_ThreadModel> ObjectLock;<\/p>\n

\u00a0<\/span><\/p>\n

ULONG InternalAddRef<\/span><\/strong>()<\/p>\n

{<\/span><\/p>\n

ATLASSERT(m_dwRef != -1L);<\/p>\n

return _ThreadModel::Increment<\/span><\/strong>(&m_dwRef);<\/p>\n

}<\/span><\/p>\n

ULONG InternalRelease<\/span><\/strong>()<\/p>\n

{<\/span><\/p>\n

ATLASSERT(m_dwRef > 0);<\/p>\n

return _ThreadModel::Decrement<\/span><\/strong>(&m_dwRef);<\/p>\n

}<\/span><\/p>\n

\u00a0<\/span><\/p>\n

void Lock<\/span><\/strong>() {m_critsec.Lock<\/span><\/strong>();}<\/p>\n

void Unlock<\/span><\/strong>() {m_critsec.Unlock<\/span><\/strong>();}<\/p>\n

private:<\/span><\/p>\n

_CritSec m_critsec;<\/p>\n

};<\/span><\/p>\n

Because the two classes has the same interfaces, if you want<\/p>\n

to change the threading model of an existing component, all you need to do is<\/p>\n

simply swapping between CComSingleThreadModel<\/strong> and CComMultiThreadModel<\/strong>.<\/p>\n

In class CComSingleThreadModel<\/strong> which is used for STA<\/p>\n

components, method Increment<\/strong> andDecrement<\/strong><\/p>\n

simply use “++” or “- -” operation on the object reference<\/p>\n

count, and it typedefs CComFakeCriticalSection<\/strong> as the classes providing Lock<\/strong><\/p>\n

and Unlock,<\/strong> which does nothing:<\/p>\n

\u00a0<\/span><\/p>\n

class CComSingleThreadModel<\/span><\/strong><\/span><\/p>\n

{<\/span><\/p>\n

public:<\/span><\/p>\n

static ULONG WINAPI Increment<\/span><\/strong>(LPLONG<\/p>\n

p) {return ++(*p);}<\/p>\n

static ULONG WINAPI Decrement<\/span><\/strong>(LPLONG<\/p>\n

p) {return –(*p);}<\/p>\n

\u00a0<\/span><\/p>\n

typedef CComFakeCriticalSection<\/span><\/strong><\/p>\n

AutoCriticalSection;<\/p>\n

typedef<\/span><\/p>\n

CComFakeCriticalSection CriticalSection;<\/p>\n

typedef CComSingleThreadModel ThreadModelNoCS;<\/p>\n

};<\/span><\/p>\n

\u00a0<\/span><\/p>\n

class CComFakeCriticalSection<\/span><\/p>\n

{<\/span><\/p>\n

public:<\/span><\/p>\n

void Lock<\/span><\/strong>() {}<\/p>\n

void Unlock<\/span><\/strong>() {}<\/p>\n

void Init() {}<\/p>\n

void Term() {}<\/p>\n

};<\/span><\/p>\n

Because CComSingleThreadModel<\/strong>actually provides no useful thread-protecting<\/p>\n

code at all, you have to use cirtical section functions to protect your global<\/p>\n

and static data.<\/p>\n

In comparison, in class CComMultiThreadModel<\/strong> which is<\/p>\n

used for MTA components, method Increment<\/strong> and Decrement<\/strong> uses API<\/p>\n

function InterlockedIncrement<\/strong> and InterlockedDecrement<\/strong> to safely<\/p>\n

operate on data member m_refCount<\/strong>, and it typedefs CComAutoCriticalSection<\/strong><\/p>\n

to provide method Lock<\/strong> and Unlock<\/strong>, which extends to critical<\/p>\n

section function calls:<\/p>\n

\u00a0<\/span><\/p>\n

class CComMultiThreadModel<\/span><\/strong><\/span><\/p>\n

{<\/span><\/p>\n

public:<\/span><\/p>\n

static<\/span><\/p>\n

ULONG WINAPI Increment<\/span><\/strong>(LPLONG p) {return InterlockedIncrement<\/span><\/strong>(p);}<\/p>\n

static<\/span><\/p>\n

ULONG WINAPI Decrement<\/span><\/strong>(LPLONG p) {return InterlockedDecrement<\/span><\/strong>(p);}<\/p>\n

\u00a0<\/span><\/p>\n

typedef<\/span><\/p>\n

CComAutoCriticalSection<\/span><\/strong><\/p>\n

AutoCriticalSection;<\/p>\n

typedef<\/span><\/p>\n

CComCriticalSection CriticalSection;<\/p>\n

typedef<\/span><\/p>\n

CComMultiThreadModelNoCS ThreadModelNoCS;<\/p>\n

};<\/span><\/p>\n

\u00a0<\/span><\/p>\n

class CComAutoCriticalSection<\/span><\/strong><\/span><\/p>\n

{<\/span><\/p>\n

public:<\/span><\/p>\n

void Lock<\/span><\/strong>() {EnterCriticalSection<\/span><\/strong>(&m_sec);}<\/span><\/p>\n

void Unlock<\/span><\/strong>() {LeaveCriticalSection<\/span><\/strong>(&m_sec);}<\/span><\/p>\n

CComAutoCriticalSection()<\/span><\/p>\n

{InitializeCriticalSection(&m_sec);}<\/p>\n

~CComAutoCriticalSection()<\/span><\/p>\n

{DeleteCriticalSection(&m_sec);}<\/p>\n

CRITICAL_SECTION<\/span><\/strong> m_sec;<\/span><\/p>\n

};<\/span><\/p>\n

To protect other data in the coclass, simply call method Lock<\/strong><\/p>\n

and Unlock<\/strong>.<\/p>\n

<\/a><\/a>9.7.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>How do Clients Decide Their Threading Model<\/span><\/h2>\n

Because all COM components must be placed in apartments, if<\/p>\n

a thread wants to access a component, it must create an apartment or enter an<\/p>\n

existing one. This is done by calling function CoInitializeEx<\/strong> passing<\/p>\n

NULL and COINIT_MULTITHREADED<\/strong> for MTA or COINIT_APARTMENTTHREADED<\/strong><\/p>\n

for STA. Before you use CoInitializeEx<\/strong>, make sure you have defined _WIN32_DCOM<\/strong>.<\/p>\n

<\/a><\/a>9.8.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>Marshalling Interface Pointer Between<\/span><\/h2>\n

Appartments<\/p>\n

<\/a><\/h2>\n

The rule is: when you move an interface pointer across the apartment<\/p>\n

boundary, it must be marshalled. When you move an interface pointer through COM<\/p>\n

API function calls such as CoCreateInstance<\/strong> or QueryInterface<\/strong>, or<\/p>\n

pass it as a parameter in a COM method call, COM run time will take care of the<\/p>\n

marshalling. However, when COM is not involved in the marshalling, you have to<\/p>\n

marshal the interface pointer yourself.<\/p>\n

In the following example, COM server Threads<\/strong> defines<\/p>\n

an call-back interface ICallBack<\/strong>. Another COM server implements ICallBack<\/strong><\/p>\n

interface. The client creates an instance of both of the servers, call server Threads<\/strong>‘s<\/p>\n

Advise<\/strong> method to pass it the pointer to the implemented ICallBack<\/strong>.<\/p>\n

Then the client calls coclass Source<\/strong>‘s DoWork<\/strong> method, which<\/p>\n

spawns a new thread passing the ICallBack<\/strong> pointer. The thread will call<\/p>\n

the call back method of ICallBack<\/strong> to do its job.<\/p>\n

In this example, coclass Source<\/strong> is in STA, while the<\/p>\n

thread it creats enters the MTA. Some book says in such case because the<\/p>\n

calling through interface pointer is not between client and server and thus not<\/p>\n

taken care of by COM run time, you have to marshal the interface yourself. So I<\/p>\n

did this in this example, but it works fine even if you don’t marshal it at<\/p>\n

all!<\/p>\n

\u00a0<\/span><\/p>\n

STDMETHODIMP CSource::Advise(ICallBack<\/span><\/p>\n

*pCallBack)<\/p>\n

{<\/span><\/p>\n

m_pCallBack = pCallBack;<\/p>\n

return S_OK;<\/p>\n

}<\/span><\/p>\n

\u00a0<\/span><\/p>\n

STDMETHODIMP CSource::DoWork()<\/span><\/p>\n

{<\/span><\/p>\n

<\/a>PARAM * pParam =<\/span><\/p>\n

 <\/p>\n

(PARAM *)CoTaskMemAlloc(sizeof(PARAM) + 50000 * sizeof(LONG));<\/p>\n

pParam->sSize = 50000;<\/p>\n

for(LONG i = 0; i < 50000; i++)<\/p>\n

pParam->sArray[i] = i;<\/p>\n

\u00a0<\/span><\/p>\n

IStream * ps = NULL;<\/p>\n

HRESULT hr = CoMarshalInterThreadInterfaceInStream<\/span><\/strong><\/span><\/p>\n

(IID_ICallBack, m_pCallBack, &ps);<\/p>\n

pParam->ps = ps;<\/p>\n

\u00a0<\/span><\/p>\n

DWORD dw;<\/p>\n

HANDLE h = CreateThread<\/span><\/strong>(0, 0,<\/p>\n

AThread, (void *)pParam, 0, &dw);<\/p>\n

CloseHandle<\/span><\/strong>(h);<\/span><\/p>\n

\u00a0<\/span><\/p>\n

Sleep(3000);<\/p>\n

return S_OK;<\/p>\n

}<\/span><\/p>\n

\u00a0<\/span><\/p>\n

\/\/ Global thread function with arbitrary name<\/span><\/p>\n

but standard signature<\/p>\n

DWORD WINAPI AThread(void * p)<\/span><\/p>\n

{<\/span><\/p>\n

CoInitializeEx<\/span><\/strong>(NULL, COINIT_MULTITHREADED<\/span><\/strong>);<\/span><\/p>\n

PARAM * pParam = (PARAM *)p;<\/p>\n

ICallBack * pCallBack = NULL;<\/p>\n

HRESULT hr = CoGetInterfaceAndReleaseStream<\/span><\/strong><\/p>\n

(pParam->ps, IID_ICallBack, (void **)&pCallBack);<\/p>\n

\u00a0<\/span><\/p>\n

char buf[80];<\/p>\n

for(LONG i = 0; i < pParam->sSize; i++)<\/p>\n

{<\/span><\/p>\n

if(i % 10000 == 0)<\/p>\n

{<\/p>\n

sprintf(buf, “pParam->sArray[%d] = %d”, i,<\/p>\n

pParam->sArray[i]);<\/p>\n

m(buf);<\/span><\/p>\n

}<\/p>\n

}<\/span><\/p>\n

\u00a0<\/span><\/p>\n

LONG * ps = (LONG *)CoTaskMemAlloc(100000 * sizeof(LONG));<\/p>\n

for(i = 0; i < 100000; i++)<\/p>\n

ps[i] = i;<\/p>\n

pCallBack->CallBackMethod(100000, ps);<\/p>\n

\u00a0<\/span><\/p>\n

CoUninitialize<\/span><\/strong>();<\/span><\/p>\n

return 0;<\/p>\n

}<\/span><\/p>\n

<\/a><\/a>9.9.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>ATL Server’s Default Threading Support<\/span><\/h2>\n

Every project generated with ATL COM AppWizard defines a<\/p>\n

default threading model in the precompiled header file stdafx.h. This model<\/p>\n

accounts for threading issues that you do not need to concern, such as how ATL<\/p>\n

locks its global data:<\/p>\n

\u00a0<\/span><\/p>\n

#define _ATL_APARTMENT_THREADED<\/span><\/p>\n

There are three options: _ATL_SINGLE_THREADED<\/strong>, _ATL_APARTMENT_THREADED<\/strong><\/p>\n

and _ATL_FREE_THREADED<\/strong>.<\/p>\n

In <atlbase.h>, there are following typedefs based on<\/p>\n

the above definition:<\/p>\n

\u00a0<\/span><\/p>\n

#if defined(_ATL_SINGLE_THREADED)<\/span><\/p>\n

typedef<\/span><\/p>\n

CComSingleThreadModel CComObjectThreadModel;<\/p>\n

typedef<\/span><\/p>\n

CComSingleThreadModel CComGlobalsThreadModel;<\/p>\n

\u00a0<\/span><\/p>\n

#elif defined(_ATL_APARTMENT_THREADED)<\/span><\/p>\n

typedef<\/span><\/p>\n

CComSingleThreadModel CComObjectThreadModel;<\/p>\n

typedef<\/span><\/p>\n

CComMultiThreadModel CComGlobalsThreadModel;<\/p>\n

\u00a0<\/span><\/p>\n

#else<\/span><\/p>\n

typedef<\/span><\/p>\n

CComMultiThreadModel CComObjectThreadModel;<\/p>\n

typedef<\/span><\/p>\n

CComMultiThreadModel CComGlobalsThreadModel;<\/p>\n

#endif<\/span><\/p>\n

Therefore, the definition of default threading model must<\/p>\n

proceed the include of <atlbase.h>.<\/p>\n

<\/a><\/a>10.<\/span><\/span>Other<\/span><\/h1>\n

ATL Supporting Classes<\/p>\n

<\/a><\/h1>\n

<\/a><\/a>10.1.\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><\/span><\/h2>\n

 <\/p>\n

<\/a>CComObject<> Template Classes \u2013 Creatable<\/span><\/h2>\n

Coclasses<\/p>\n

<\/a><\/h2>\n

The coclass you create with COM AppWizard does not contain<\/p>\n

the implementation of IUnknown<\/strong> methods. Therefore they are abstract<\/p>\n

classes. They can not be directly created. Instead a coclass is passed to one<\/p>\n

of a set of template classes, which inherits from the coclass passed as<\/p>\n

template parameter, and provides a specific implementation of the IUnknown<\/strong><\/p>\n

methods. This template classes become the real creatable coclasses.<\/p>\n

The reason behind these logic is to separate the custom<\/p>\n

implementation of coclasses from the implementation of IUnknown, so that the<\/p>\n

ATL coclasses are more portable.<\/p>\n

The definition of the most commonly used template class CComObject<\/strong><><\/p>\n

is listed below:<\/p>\n

\u00a0<\/span><\/p>\n

template <class Base<\/span><\/strong>><\/span><\/p>\n

class CComObject<\/span><\/strong><\/span><\/p>\n

: public<\/span><\/strong> Base<\/span><\/strong><\/p>\n

{<\/span><\/p>\n

public:<\/span><\/p>\n

typedef Base _BaseClass;<\/p>\n

\u00a0<\/span><\/p>\n

CComObject(void* = NULL)<\/p>\n

{<\/span><\/p>\n

_Module.Lock(); \/\/ _Module is the global CComModule<\/p>\n

}<\/span><\/p>\n

~CComObject() \/\/ Set refcount to 1 to protect destruction<\/p>\n

{<\/span><\/p>\n

m_dwRef = 1L;<\/p>\n

FinalRelease();<\/p>\n

_Module.DeleteNonAddRefThunk(_GetRawUnknown());<\/p>\n

_Module.Unlock();<\/p>\n

}<\/span><\/p>\n

\u00a0<\/span><\/p>\n

STDMETHOD_(ULONG, AddRef<\/span><\/strong>)()<\/p>\n

{<\/span><\/p>\n

return InternalAddRef<\/span><\/strong>();<\/p>\n

}<\/span><\/p>\n

\u00a0<\/span><\/p>\n

STDMETHOD_(ULONG, Release<\/span><\/strong>)()<\/p>\n

{<\/span><\/p>\n

ULONG l = InternalRelease<\/span><\/strong>();<\/p>\n

if (l == 0)<\/p>\n

delete this;<\/p>\n

return l;<\/p>\n

}<\/span><\/p>\n

\u00a0<\/span><\/p>\n<\/div>\n","protected":false},"excerpt":{"rendered":"

COM Tutorial COM & ATL Silan Liu \u00a0 1.\u00a0\u00a0\u00a0\u00a0\u00a0 COM Basics   1.1.\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0   Service Control Manager (SCM) A Windows program called Service Control Manager (SCM) does most of the job in COM server invoking. It finds the server through … Continue reading →<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"parent":305,"menu_order":0,"comment_status":"open","ping_status":"open","template":"","meta":{"footnotes":""},"class_list":["post-318","page","type-page","status-publish","hentry"],"_links":{"self":[{"href":"https:\/\/templesystems.com\/index.php?rest_route=\/wp\/v2\/pages\/318","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/templesystems.com\/index.php?rest_route=\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/templesystems.com\/index.php?rest_route=\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/templesystems.com\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/templesystems.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=318"}],"version-history":[{"count":5,"href":"https:\/\/templesystems.com\/index.php?rest_route=\/wp\/v2\/pages\/318\/revisions"}],"predecessor-version":[{"id":322,"href":"https:\/\/templesystems.com\/index.php?rest_route=\/wp\/v2\/pages\/318\/revisions\/322"}],"up":[{"embeddable":true,"href":"https:\/\/templesystems.com\/index.php?rest_route=\/wp\/v2\/pages\/305"}],"wp:attachment":[{"href":"https:\/\/templesystems.com\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=318"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}

<\/a>CoTaskMemFree<\/span><\/strong>(*ppg);<\/span><\/p>\n

<\/a>REGEDIT<\/span><\/p>\n

<\/a>LIBRARY<\/span><\/strong><\/p>\n