Windows RPC编程入门

    Windows本身支持成为一个RPC服务器。MSDN里面有个很好的例子，但是，WindowsXP上面默认的RPC/tcpip功能没有打开，必须运行gpedit.msc，计算机配置->管理模版->系统->远程过程调用->用于未验证的RPC...->选择"已启动"，限定项选择"无"。用VC2010express建立两个工程，按照MSDN的例子:
    首先，idl文件my.idl:

[   uuid(ba209999-0c6c-11d2-97cf-00c04f8eea45),   version(1.0) ] interface hw // The interface is named hw {    // A function that takes a zero-terminated string.    void Hello(       [in, string] const char* szOutput); }

    编译以后，相应的文件放到服务器端和客户端程序里面去。
    服务器端实现:

#include"stdafx.h" #include<stdio.h> #include<stdlib.h> #include"my_h.h" #pragma comment(lib,"rpcrt4") #pragma comment(lib,"ole32") extern "C"{ void Hello(handle_t IDL_handle,const unsigned char*psz){     printf("server:%s\n",psz); } void Shutdown(handle_t IDL_handle){     RpcMgmtStopServerListening(NULL);     RpcServerUnregisterIf(NULL,NULL,FALSE); } void* /*__RPC_FAR**/ __RPC_USER midl_user_allocate(size_t len){     return(malloc(len)); } void __RPC_USER midl_user_free(void __RPC_FAR* ptr){     free(ptr); } } int main() {    RPC_STATUS status;    status = RpcServerUseProtseqEp(       (RPC_CSTR)("ncacn_ip_tcp"), // Use TCP/IP protocol.       RPC_C_PROTSEQ_MAX_REQS_DEFAULT, // Backlog queue length for TCP/IP.       (RPC_CSTR)("4747"), // TCP/IP port to use.       NULL); // No security.    if (status){        printf("ServerUse failed\n");        exit(status);}    else printf("UseProtseqEq ok\n");    status = RpcServerRegisterIf(       hw_v1_0_s_ifspec, // Interface to register.       NULL, // Use the MIDL generated entry-point vector.       NULL);// Use the MIDL generated entry-point vector.    if (status){        printf("Register failed\n");        exit(status);}    else printf("Register if ok\n");    // This call will not return until    // RpcMgmtStopServerListening is called.    status = RpcServerListen(      1, // Recommended minimum number of threads.      RPC_C_LISTEN_MAX_CALLS_DEFAULT, // Recommended maximum number of threads.      FALSE); // Start listening now.    if (status){        printf("Server listen failed\n");        exit(status);}    else printf("listen ok\n");    return 0; }

    启动以后显示:
UseProtseqEq ok
Register if ok
    客户端代码:

// myclient.cpp : Defines the entry point for the console application. #include"stdafx.h" #include<windows.h> #include<stdio.h> #include"my_h.h" #pragma comment(lib,"rpcrt4") #pragma comment(lib,"ole32") int main(void){     RPC_STATUS status;     RPC_BINDING_HANDLE hwBinding;     unsigned char* szStringBinding=NULL;     status=RpcStringBindingCompose(//建立一个String Binding句柄，并不连接         NULL,         (RPC_CSTR)("ncacn_ip_tcp"),         (RPC_CSTR)("localhost"),         (RPC_CSTR)("4747"),         NULL,         (RPC_CSTR*)&szStringBinding);     if(status){         printf("StringBinding failed\n");         exit(status);}     printf("szString=%s\n",szStringBinding);     status=RpcBindingFromStringBinding(         szStringBinding,         &hwBinding);     if(status){         printf("Bind from String failed:%d\n",GetLastError());         exit(status);}     RpcTryExcept{                 Hello(hwBinding,(RPC_CSTR)("Hello RPC World!"));    }    RpcExcept(1){       printf("Runtime reported exception:%d,except=%d\n",GetLastError(),RpcExceptionCode()/*RPC_S_ACCESS_DENIED==5L*/);//这里返回了5    }    RpcEndExcept    status = RpcBindingFree(&hwBinding); // Frees the binding handle.    if (status){        printf("Bind free failed\n");        exit(status);}     return 0; } void* __RPC_USER midl_user_allocate(size_t size){     return malloc(size); } // Memory deallocation function for RPC. void __RPC_USER midl_user_free(void* p){     free(p); }

    运行显示:
szString=ncacn_ip_tcp:localhost[4747]

    此时，服务器端显示:
server:Hello RPC World!
    多次启动客户端，上面这句话显示多次。

---------------------------------------------------------
    自己写的com客户端的代码，放到blog里面作为备份。

点击(此处)折叠或打开

1. #include<algorithm>
   
2. #include<cassert>
   
3. #include<type_traits>
   
4. #include<iostream>
   
5. #include<iterator>
   
6. using namespace std;
   
7. 
   
8. #import "..\ATLProject1\Debug\ATLProject1.tlb" no_namespace raw_native_types named_guids
   
9. #import "..\ATLProject3\Debug\ATLProject3.tlb" no_namespace raw_native_types named_guids
   
10. #import "..\ATLProject5\Debug\ATLProject5.tlb" no_namespace raw_native_types named_guids
    
11. #import "..\cs_ClassLibrary1\bin\Debug\cs_ClassLibrary1.tlb" no_namespace raw_native_types named_guids
    
12. 
    
13. void UseCSharpCom()
    
14. {
    
15.     MyCom_InterfacePtr p(CLSID_Class1,NULL,CLSCTX_ALL);
    
16.     printf("%d\n",p->Add(3,9));
    
17.     p.Release();
    
18. }
    
19. 
    
20. void UsingGeneratedPtr()
    
21. {
    
22.     IMyErrPtr p(CLSID_MyErr,NULL,CLSCTX_ALL);
    
23.     LONG ret;
    
24.     HRESULT r=p->Sub(&ret,33,48);
    
25.     printf("%d\n",ret);
    
26.     p.Release();
    
27. }
    
28. 
    
29. void fv(){}
    
30. short fs(){return 0;}
    
31. int fi(){return 0;}
    
32. double fd(){return 0;}
    
33. int (*pfi);
    
34. short (*pfs);
    
35. using namespace std;
    
36. 
    
37. template <class T, size_t n>
    
38. char (*pc(T (&arr)[n]))[n];
    
39. 
    
40. void ApiDispatch()
    
41. {
    
42.     CLSID id;
    
43.     HRESULT hr=CLSIDFromProgID(L"my.fun",&id);
    
44.     assert( SUCCEEDED( hr ) );
    
45. 
    
46.     CoInitialize(NULL);
    
47. 
    
48.     IDispatch* pDisp=NULL;
    
49.     hr=CoCreateInstance(id,NULL,CLSCTX_ALL,IID_IDispatch,(void**)&pDisp);
    
50.     assert( SUCCEEDED( hr ) );
    
51. 
    
52.     LPOLESTR pstrName=L"Add";
    
53.     DISPID fID(0);
    
54.     hr=pDisp->GetIDsOfNames(IID_NULL,&pstrName,1,LOCALE_SYSTEM_DEFAULT,&fID);
    
55.     assert( SUCCEEDED( hr ) );
    
56. 
    
57.     VARIANT v[2],vResult;
    
58.     v[0].vt=VT_I4;
    
59.     v[1].vt=VT_I4;
    
60. 
    
61.     v[0].lVal=33;
    
62.     v[1].lVal=48;
    
63.     DISPPARAMS param={v,NULL,2,0};
    
64.     hr=pDisp->Invoke(fID,IID_NULL,LOCALE_SYSTEM_DEFAULT,DISPATCH_METHOD,&param,&vResult,NULL,NULL);
    
65.     assert( SUCCEEDED( hr ) );
    
66.     printf("result=%d\n",vResult.lVal);
    
67. 
    
68.     pDisp->Release();
    
69.     CoUninitialize();
    
70. }
    
71. 
    
72. void ATLDispatch()
    
73. {
    
74.     CLSID id;
    
75.     HRESULT hr=CLSIDFromProgID(L"my.fun",&id);
    
76.     assert( SUCCEEDED( hr ) );
    
77. 
    
78.     CoInitialize(NULL);
    
79.     CComDispatchDriver spDisp;
    
80.     hr=CoCreateInstance(id,NULL,CLSCTX_ALL,IID_IUnknown,(void**)&spDisp);
    
81.     assert( SUCCEEDED( hr ) );
    
82.     CComVariant v[3],vResult;
    
83.     v[0]=33;
    
84.     v[1]=48;
    
85.     v[2]=2;
    
86.     hr=spDisp.InvokeN(L"Add3",v,3,&vResult);
    
87.     assert( SUCCEEDED( hr ) );
    
88.     printf("result=%d\n",vResult.lVal);
    
89.     spDisp.Release();
    
90.     CoUninitialize();
    
91. }
    
92. 
    
93. void f()
    
94. {
    
95. //
    
96. // 1,2
    
97. // 11,22
    
98. // 31,32
    
99. // 41,42
    
100. // 51,52
     
101. //
     
102. 
     
103.     #define dim 2
     
104.     SAFEARRAYBOUND b[dim];
     
105.     b[0].cElements=5;
     
106.     b[0].lLbound=0;
     
107.     b[1].cElements=2;
     
108.     b[1].lLbound=0;
     
109.     SAFEARRAY* psa=SafeArrayCreate(VT_I4,dim,b);
     
110.     long Idx[dim];
     
111.     int x=0;
     
112.     for(size_t i=0;i<5;++i)
     
113.     {
     
114.         for(size_t j=0;j<2;++j)
     
115.         {
     
116.             Idx[0]=i;
     
117.             Idx[1]=j;
     
118.             x=i*10+j+1;
     
119.             SafeArrayPutElement(psa,Idx,&x);
     
120.         }
     
121.     }
     
122.     int* pi=0;;
     
123.     HRESULT hr=SafeArrayAccessData(psa,(void**)&pi);
     
124.     copy(pi,pi+10,ostream_iterator<int>(cout,","));
     
125.     SafeArrayUnaccessData(psa);
     
126.     SafeArrayDestroy(psa);
     
127. }
     
128. 
     
129. class CSink: public ICallBack
     
130. {
     
131. public:
     
132.     STDMETHODIMP QueryInterface(const struct _GUID&iid,void**ppv)
     
133.     {
     
134.         *ppv=this;
     
135.         return S_OK;
     
136.     }
     
137.     ULONG __stdcall AddRef(void) {return 1;}
     
138.     ULONG __stdcall Release(void){return 0;}
     
139.     STDMETHODIMP raw_Fire_Result(long nResult)
     
140.     {
     
141.         cout<<"fire"<<nResult<<endl;
     
142.         return S_OK;
     
143.     }
     
144. };
     
145. 
     
146. void UseEventClient()
     
147. {
     
148.     cout<<__FUNCTION__<<endl;
     
149.     CComQIPtr<IEvent1> pe;
     
150.     pe.CoCreateInstance(CLSID_Event1,NULL,CLSCTX_ALL);
     
151.     if(pe)
     
152.     {
     
153.         cout<<"Call com event"<<endl;
     
154.         CSink client1;
     
155.         ULONG cookie=30;
     
156.         pe->Register(&client1,&cookie);
     
157.         pe->Add(33,99);
     
158.         pe->Unregister(cookie);
     
159.     }
     
160.     pe.Release();
     
161. }
     
162. 
     
163. void UseSafeArray()
     
164. {
     
165.     CComSafeArray<int> a(2,0);
     
166.     CComSafeArrayBound bounds[]={(2,0),(3,0),(4,0)};
     
167.     CComSafeArray<int> sa(bounds,_countof(bounds));
     
168.     long index[]={3,2,1};
     
169.     sa.MultiDimSetAt(index,200);
     
170. }
     
171. 
     
172. IFunPtr pf;
     
173. UINT __stdcall mytf(void* pArg)
     
174. {
     
175.     cout<<"Thread function"<<endl;
     
176.     CoInitialize(NULL);
     
177. 
     
178.     HRESULT hr=pf.CreateInstance(CLSID_Fun,NULL);//,CLSCTX_REMOTE_SERVER);
     
179.     cout<<pf->Add(2,3)<<endl;
     
180.     Sleep(2000);
     
181.     cout<<"Thread ends"<<endl;
     
182.     pf.Release();
     
183.     CoUninitialize();
     
184.     _endthreadex(0);
     
185.     return 0;
     
186. }
     
187. 
     
188. void f3()
     
189. {
     
190.     //_beginthreadex(NULL,0,mytf,NULL,0,NULL);//如何Join?
     
191.     CoInitialize(NULL);
     
192.     IFun* p1,*p2;
     
193.     HRESULT hr=::CoCreateInstance(CLSID_Fun,NULL,CLSCTX_ALL,IID_IFun,(void**)&p1);
     
194.     hr=::CoCreateInstance(CLSID_Fun,NULL,CLSCTX_ALL,IID_IFun,(void**)&p2);
     
195.     assert(p1!=p2);
     
196.     p2->Release();
     
197.     p1->Release();
     
198.     CoUninitialize();
     
199. }
     
200. 
     
201. class Father
     
202. {
     
203. public:
     
204.     int i;
     
205.     Father(){i=22;}
     
206.     virtual void f(){printf("f:%d\n",i);}
     
207.     virtual void g(){printf("g:%d\n",i);}
     
208.     virtual void h(){printf("h:%d\n",i);}
     
209. };
     
210. class Child:public Father
     
211. {
     
212. public:
     
213.     void f(){printf("child f\n");}
     
214. };
     
215. typedef void (__thiscall *pFather)(Father*);
     
216. void fVTable()
     
217. {
     
218.     Father* pf=new Father;
     
219.     Father* pf2=new Father;
     
220.     pf->f();
     
221.     printf("pf =%p\npf->i=%p\n",pf,&(pf->i));
     
222.     pFather *pVtable=*(pFather**)(pf);
     
223.     pVtable[0](pf);
     
224.     pVtable[1](pf);
     
225.     pVtable[2](pf);
     
226.     delete pf;
     
227.     delete pf2;
     
228.     
     
229.     Father* pc=new Child;
     
230.     printf("Father vtable=%p,%p\nChild vtable=%p\n",
     
231.         *(int*)(pf),
     
232.         *(int*)(pf2),
     
233.         *(int*)(pc));
     
234.     (*(pFather**)(pc))[0](pc);
     
235. }
     
236. 
     
237. void UsingISupportError(bool fThrowException=false)
     
238. {
     
239.     IMyErrPtr p(CLSID_MyErr,NULL,CLSCTX_ALL);
     
240.     try
     
241.     {
     
242.         HRESULT hr;
     
243.         if(fThrowException)
     
244.         {
     
245.             LONG ret=0;
     
246.             hr=p->Sub(&ret,33,81);//ATL CComCoClass::Error will throw an exception
     
247.             printf("%d\n",ret);
     
248.         }
     
249.         else
     
250.         {
     
251.             hr=p->raw_Sub2(LONG());
     
252.             CComQIPtr<ISupportErrorInfo> spSEI=p;
     
253.             if(spSEI)
     
254.             {
     
255.                 puts("support!");
     
256.                 hr=spSEI->InterfaceSupportsErrorInfo(IID_IMyErr);
     
257.                 if(SUCCEEDED(hr))
     
258.                 {
     
259.                     CComQIPtr<IErrorInfo> spError;
     
260.                     hr=GetErrorInfo(0,&spError);
     
261.                     if(SUCCEEDED(hr))
     
262.                     {
     
263.                         CComBSTR bstr;
     
264.                         spError->GetDescription(&bstr);
     
265.                         LPWSTR s1=bstr;
     
266.                         LPCTSTR s2=OLE2CT(s1);
     
267.                         _tprintf(_T("%s\n"),s2);
     
268.                     }
     
269.                 }
     
270.             }
     
271.             spSEI.Release();
     
272.         }
     
273.     }
     
274.     catch(_com_error &e)
     
275.     {
     
276.         LPWSTR s=e.Description();
     
277.         _tprintf(_T("%s\n"),OLE2CT(s));
     
278.     }
     
279.     p.Release();
     
280. }
     
281. 
     
282. void UseCComSafeArray()
     
283. {
     
284.        CComSafeArrayBound bounds[]={CComSafeArrayBound(2,0),CComSafeArrayBound(3,0),CComSafeArrayBound(4,0)};
     
285.     CComSafeArray<int> arr(bounds,_countof(bounds));
     
286.     SAFEARRAY* psa=arr.m_psa;
     
287.     cout<<psa->cbElements<<','<<psa->cDims<<endl;
     
288.     cout<<arr.GetCount(0)<<','<<arr.GetCount(1)<<','<<arr.GetCount(2)<<endl;
     
289.     CComVariant v=psa;//::SafeArrayCopy() is called
     
290. }
     
291. /*
     
292. void MFCDispatch()
     
293. {
     
294.     CoInitialize(NULL);
     
295.     CFun f;
     
296.     f.CreateDispatch(L"my.fun");
     
297.     printf("%d\n",f.Add(33,48));
     
298.     f.ReleaseDispatch();
     
299.     CoUninitialize();
     
300. }
     
301. */
     
302. class CPropertyBag: public IPropertyBag
     
303. {
     
304. public:
     
305.     STDMETHODIMP CPropertyBag::QueryInterface(const struct _GUID &iid,void ** ppv)
     
306.     {
     
307.         *ppv = this;
     
308.         return S_OK;
     
309.     }
     
310.     STDMETHODIMP_(ULONG) CPropertyBag::AddRef(void) {return 1;}
     
311.     STDMETHODIMP_(ULONG) CPropertyBag::Release(void){return 0;}
     
312.     STDMETHODIMP CPropertyBag::Read(LPCOLESTR pszPropName,VARIANT *pVar,IErrorLog *pErrorLog)
     
313.     {
     
314.         cout<<__FUNCTION__<<','<<pVar->vt<<endl;
     
315.         if( pVar->vt == VT_BSTR )
     
316.         {
     
317.             pVar->bstrVal=OLE2BSTR(L"mystring");
     
318.             return S_OK;
     
319.         }
     
320.         else if( pVar->vt == VT_I4 )
     
321.         {
     
322.             pVar->lVal=207;
     
323.             return S_OK;
     
324.         }
     
325.         else return E_FAIL;
     
326.     }
     
327.     STDMETHODIMP CPropertyBag::Write(LPCOLESTR pszPropName,VARIANT *pVar)
     
328.     {
     
329.         return S_OK;
     
330.     }
     
331. };
     
332. void UsePropBag()
     
333. {
     
334.     IPersistPropertyBagPtr ptr(CLSID_Property,NULL,CLSCTX_ALL);
     
335.     if(ptr)
     
336.     {
     
337.         CPropertyBag bag;
     
338.         ptr->Load(&bag,NULL);
     
339.         ptr.Release();
     
340.     }
     
341. }
     
342. 
     
343. void UseAggregation()
     
344. {
     
345.     IMyAggrPtr sp1(CLSID_MyAggr,NULL,CLSCTX_ALL);
     
346.     IFooPtr spFoo;
     
347.     sp1->QueryInterface(&spFoo);
     
348.     cout<<spFoo->Add(3,4)<<endl;
     
349.     spFoo.Release();
     
350.     sp1.Release();
     
351. }
     
352. 
     
353. class CPSink : public IDispatch
     
354. {
     
355. public:
     
356.     STDMETHODIMP QueryInterface(const struct _GUID &iid,void ** ppv)
     
357.     {
     
358.         *ppv=this;
     
359.         return S_OK;
     
360.     }
     
361.     STDMETHODIMP_(ULONG) AddRef(void){return 1;}
     
362.     STDMETHODIMP_(ULONG) Release(void){return 0;}
     
363.     STDMETHODIMP GetTypeInfoCount(unsigned int *){return E_NOTIMPL;}
     
364.     STDMETHODIMP GetTypeInfo(unsigned int,unsigned long,struct ITypeInfo ** ){return E_NOTIMPL;}
     
365.     STDMETHODIMP GetIDsOfNames(const IID &,LPOLESTR *,UINT,LCID,DISPID *){return E_NOTIMPL;}
     
366.     STDMETHODIMP Invoke(
     
367.         long dispID,
     
368.         const struct _GUID &,
     
369.         unsigned long,
     
370.         unsigned short,
     
371.         struct tagDISPPARAMS * pParams,
     
372.         struct tagVARIANT *,
     
373.         struct tagEXCEPINFO *,
     
374.         unsigned int *)
     
375.     {
     
376.         switch(dispID)
     
377.         {
     
378.         case 1:
     
379.             _tprintf(_T("Result=%d\n"),pParams->rgvarg[0].lVal);
     
380.         break;
     
381.         default:
     
382.             break;
     
383.         }
     
384.         return S_OK;
     
385.     }
     
386. };
     
387. 
     
388. void TestConnectionPoint()
     
389. {
     
390.     ICP1Ptr spCP1(CLSID_CP1,NULL,CLSCTX_ALL);
     
391.     CComQIPtr<IConnectionPointContainer> spContainer=spCP1;
     
392.     CComQIPtr<IConnectionPoint> spCP;
     
393.     HRESULT hr=spContainer->FindConnectionPoint(DIID__ICP1Events,&spCP);
     
394.     CPSink obj;
     
395.     DWORD dwCookie;
     
396.     spCP->Advise(&obj,&dwCookie);
     
397.     spCP1->Add(3,9);
     
398.     spCP->Unadvise(dwCookie);
     
399.     spCP.Release();
     
400.     spContainer.Release();
     
401.     spCP1.Release();
     
402. }
     
403. 
     
404. struct UseStream
     
405. {
     
406.     HRESULT hr;        // 函数执行返回值
     
407.     IStorage *pStg;
     
408.     IStorage *pSub;
     
409.     IStream *pStm;
     
410.     UseStream()
     
411.     {
     
412.      IStorage *pStg = NULL;    // 根存储接口指针
     
413.      IStorage *pSub = NULL;    // 子存储接口指针
     
414.      IStream *pStm = NULL;    // 流接口指针
     
415.         CreateDoc();
     
416.     }
     
417.     ~UseStream()
     
418.     {
     
419.         CloseDoc();
     
420.     }
     
421.     void CreateDoc()
     
422.     {
     
423.      hr = ::StgCreateDocfile(    // 建立复合文件
     
424.          L"d:\\c.stg",    // 文件名称
     
425.          STGM_CREATE | STGM_WRITE | STGM_SHARE_EXCLUSIVE,    // 打开方式
     
426.          0,        // 保留参数
     
427.          &pStg);        // 取得根存储接口指针
     
428.      assert( SUCCEEDED(hr) );    // 为了突出重点，简化程序结构，所以使用了断言。
     
429.                  // 在实际的程序中则要使用条件判断和异常处理
     
430. 
     
431.      hr = pStg->CreateStorage(    // 建立子存储
     
432.          L"SubStg",    // 子存储名称
     
433.          STGM_CREATE | STGM_WRITE | STGM_SHARE_EXCLUSIVE,
     
434.          0,0,
     
435.          &pSub);        // 取得子存储接口指针
     
436.      assert( SUCCEEDED(hr) );
     
437. 
     
438.      hr = pSub->CreateStream(    // 建立流
     
439.          L"Stm",        // 流名称
     
440.          STGM_CREATE | STGM_WRITE | STGM_SHARE_EXCLUSIVE,
     
441.          0,0,
     
442.          &pStm);        // 取得流接口指针
     
443.      assert( SUCCEEDED(hr) );
     
444.     }
     
445.     void CloseDoc()
     
446.     {
     
447.      if( pStm )    pStm->Release();// 释放流指针
     
448.      if( pSub )    pSub->Release();// 释放子存储指针
     
449.      if( pStg )    pStg->Release();// 释放根存储指针
     
450.     }
     
451.     void WriteSample()
     
452.     {
     
453.      hr = pStm->Write(        // 向流中写入数据
     
454.          "Hello",        // 数据地址
     
455.          5,        // 字节长度(注意，没有写入字符串结尾的\0)
     
456.          NULL);        // 不需要得到实际写入的字节长度
     
457.      assert( SUCCEEDED(hr) );
     
458.         
     
459.      IPersistStreamInitPtr spStream(CLSID_MySingle,NULL,CLSCTX_ALL);
     
460.      if(spStream)
     
461.      {
     
462.          spStream->InitNew();
     
463.          spStream->Save(pStm,TRUE);
     
464.          spStream.Release();
     
465.      }
     
466.     }
     
467.     void WriteMarshalToDocument()
     
468.     {
     
469.         IFunPtr ptr(CLSID_Fun,NULL,CLSCTX_ALL);
     
470.         assert(ptr);
     
471.         CoMarshalInterface(pStm,IID_IFun,ptr,MSHCTX_LOCAL,NULL,MSHLFLAGS_NORMAL);
     
472.         ptr.Release();
     
473.     }
     
474. };
     
475. 
     
476. void SampleCreateDoc()
     
477. {
     
478.     UseStream obj1;
     
479.     obj1.WriteMarshalToDocument();
     
480. }
     
481. 
     
482. void MarshalOleAutomation()
     
483. {
     
484.     IE2Ptr ptr(CLSID_E2,NULL,CLSCTX_ALL);
     
485.     assert(ptr);
     
486.     IStream* pStm;
     
487.     HRESULT hr = CoMarshalInterThreadInterfaceInStream(IID_IE2,ptr,&pStm);
     
488.     assert(SUCCEEDED(hr));
     
489.     IE2Ptr pGet;
     
490.     hr=CoGetInterfaceAndReleaseStream(pStm,IID_IE2,(LPVOID*)&pGet);
     
491.     assert(SUCCEEDED(hr));
     
492.     cout<<pGet->Add(44,3)<<endl;//自定义接口+支持oleautomation
     
493.     ptr.Release();
     
494. }
     
495. 
     
496. class WriteMarshalToMemory
     
497. {
     
498.     static IStream* pStm;
     
499. public:
     
500.     static DWORD WINAPI f(void*)
     
501.     {
     
502.      CoInitialize(NULL);
     
503.         IE2Ptr pGet;
     
504.         HRESULT hr=CoGetInterfaceAndReleaseStream(pStm,IID_IE2,(LPVOID*)&pGet);
     
505.         assert(SUCCEEDED(hr));
     
506.         cout<<pGet->Add(44,29)<<endl;
     
507.      CoUninitialize();
     
508.         return 0;
     
509.     }
     
510.     WriteMarshalToMemory()
     
511.     {
     
512.         IE2Ptr ptr(CLSID_E2,NULL,CLSCTX_ALL);
     
513.         assert(ptr);
     
514.         HRESULT hr = CoMarshalInterThreadInterfaceInStream(IID_IE2,ptr,&pStm);
     
515.         assert(SUCCEEDED(hr));
     
516. 
     
517.         HANDLE hThread=CreateThread(NULL,size_t(),f,NULL,DWORD(),NULL);
     
518.         WaitForSingleObject(hThread,INFINITE);
     
519.         ptr.Release();
     
520.     }
     
521. };
     
522. IStream* WriteMarshalToMemory::pStm = NULL;
     
523. 
     
524. IStream* g_pStm;
     
525. DWORD WINAPI tf(void*)
     
526. {
     
527.      CoInitializeEx(NULL,COINIT_APARTMENTTHREADED);
     
528.      IMy1Ptr pGet;
     
529.      HRESULT hr=CoGetInterfaceAndReleaseStream(g_pStm,IID_IMy1,(LPVOID*)&pGet);
     
530.      assert(SUCCEEDED(hr));
     
531.      long ret=pGet->Add(44,29);
     
532.      cout<<ret<<endl;
     
533.      CoUninitialize();
     
534.      return 0;
     
535. }
     
536. void TestMarshal()
     
537. {
     
538.      CoInitializeEx(NULL,COINIT_APARTMENTTHREADED);
     
539.      IMy1Ptr ptr(CLSID_My1,NULL,CLSCTX_ALL);
     
540.      assert(ptr);
     
541.      HRESULT hr = CoMarshalInterThreadInterfaceInStream(IID_IMy1,ptr,&g_pStm);
     
542.      assert(SUCCEEDED(hr));
     
543.      HANDLE hThread=CreateThread(NULL,0,tf,NULL,0,NULL);
     
544.      Sleep(10000);//子线程调用STA主线程创建的com对象，需要用到主线程的消息队列
     
545.      MessageBox(0, _T(""), _T(""), 0);//MessageBox显示的时候创建消息队列，点击OK的时候关闭消息队列
     
546.      WaitForSingleObject(hThread,INFINITE);
     
547.      ptr.Release();
     
548.      CoUninitialize();
     
549. }
     
550. 
     
551. void UseMyStruct()
     
552. {
     
553.     IE3Ptr ptr(CLSID_E3,NULL,CLSCTX_ALL);
     
554.     My obj={2,"xyz"};
     
555.     ptr->SetMy(&obj);
     
556.     MyStruct ms={1,2};
     
557.     ptr->SetMyStruct(&ms);
     
558.     ptr->GetMy(&obj);
     
559.     cout<<obj.m_i<<obj.m_str<<endl;
     
560.     ptr.Release();
     
561. }
     
562. 
     
563. void UseClassFactory()
     
564. {
     
565.     IClassFactory *pFactory=nullptr;
     
566.     HRESULT hr=CoGetClassObject(CLSID_My1,CLSCTX_ALL,NULL,IID_IClassFactory,(void**)&pFactory);
     
567.     IMy1* pMy1=nullptr;
     
568.     hr=pFactory->CreateInstance(NULL,IID_IMy1,(void**)&pMy1);
     
569.     cout<<pMy1->Add(3,3)<<endl;
     
570.     pMy1->Release();
     
571.     pFactory->Release();
     
572. }

   ClassFactory的用法如下。

点击(此处)折叠或打开

1. int main(void)
   
2. {
   
3.     VARIANT var,var2;
   
4.     VariantInit(&var);
   
5.     VariantInit(&var2);
   
6. 
   
7.     V_VT(&var)=VT_I4;
   
8.     V_I4(&var)=20;
   
9. 
   
10.     VariantChangeType(&var2,&var,VARIANT_NOVALUEPROP,VT_BSTR);
    
11.     _tprintf(var2.bstrVal);
    
12. 
    
13.     VariantClear(&var);
    
14.     VariantClear(&var2);
    
15. 
    
16.     CoInitialize(NULL);
    
17.     IClassFactory* pf=NULL;
    
18.     HRESULT hr=CoGetClassObject(CLSID_Bar,CLSCTX_ALL,NULL,IID_IClassFactory,(void**)&pf);
    
19.     IBar* pBar=NULL;
    
20.     hr=pf->CreateInstance(NULL,IID_IBar,(void**)&pBar);
    
21.     if(pBar)pBar->Release();
    
22.     pf->Release();
    
23. 
    
24.     IClassFactory2* pf2=NULL;
    
25.     hr=CoGetClassObject(CLSID_Bar,CLSCTX_ALL,NULL,IID_IClassFactory2,(void**)&pf2);
    
26.     IBar* pBar2=NULL;
    
27.     BSTR bstrKey;
    
28.     hr=pf2->RequestLicKey(DWORD(),&bstrKey);
    
29.     hr=pf2->CreateInstanceLic(NULL,NULL,IID_IBar,bstrKey,(void**)&pBar2);
    
30.     if(pBar2)pBar2->Release();
    
31.     pf2->Release();
    
32.     CoUninitialize();
    
33.     return 0;
    
34. }