Chinaunix首页 | 论坛 | 博客

康德就在这里

首页　| 　博文目录　| 　关于我

kgisme170

  • 博客访问： 141710
  • 博文数量： 10
  • 博客积分： 2431
  • 博客等级： 大尉
  • 技术积分： 266
  • 用 户 组： 普通用户
  • 注册时间： 2009-12-02 00:56
文章分类

全部博文（10）

文章存档

2016年（1）

2013年（2）

2011年（3）

2010年（4）

我的朋友
最近访客
推荐博文
相关博文
Windows RPC编程入门

分类： C/C++

2010-10-15 21:15:44

    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;

  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

  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. }

  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. }

  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;

  37. template <class T, size_t n>
  38. char (*pc(T (&arr)[n]))[n];

  40. void ApiDispatch()
  41. {
  42.     CLSID id;
  43.     HRESULT hr=CLSIDFromProgID(L"my.fun",&id);
  44.     assert( SUCCEEDED( hr ) );

  46.     CoInitialize(NULL);

  48.     IDispatch* pDisp=NULL;
  49.     hr=CoCreateInstance(id,NULL,CLSCTX_ALL,IID_IDispatch,(void**)&pDisp);
  50.     assert( SUCCEEDED( hr ) );

  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 ) );

  57.     VARIANT v[2],vResult;
  58.     v[0].vt=VT_I4;
  59.     v[1].vt=VT_I4;

  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);

  68.     pDisp->Release();
  69.     CoUninitialize();
  70. }

  72. void ATLDispatch()
  73. {
  74.     CLSID id;
  75.     HRESULT hr=CLSIDFromProgID(L"my.fun",&id);
  76.     assert( SUCCEEDED( hr ) );

  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. }

  93. void f()
  94. {
  95. //
  96. // 1,2
  97. // 11,22
  98. // 31,32
  99. // 41,42
  100. // 51,52
  101. //

  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. }

  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. };

  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. }

  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. }

  172. IFunPtr pf;
  173. UINT __stdcall mytf(void* pArg)
  174. {
  175.     cout<<"Thread function"<<endl;
  176.     CoInitialize(NULL);

  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. }

  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. }

  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. }

  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. }

  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. }

  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. }

  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. };

  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. }

  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.                  // 在实际的程序中则要使用条件判断和异常处理

  431.      hr = pStg->CreateStorage(    // 建立子存储
  432.          L"SubStg",    // 子存储名称
  433.          STGM_CREATE | STGM_WRITE | STGM_SHARE_EXCLUSIVE,
  434.          0,0,
  435.          &pSub);        // 取得子存储接口指针
  436.      assert( SUCCEEDED(hr) );

  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. };

  476. void SampleCreateDoc()
  477. {
  478.     UseStream obj1;
  479.     obj1.WriteMarshalToDocument();
  480. }

  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. }

  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));

  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;

  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. }

  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. }

  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);

  7.     V_VT(&var)=VT_I4;
  8.     V_I4(&var)=20;

  10.     VariantChangeType(&var2,&var,VARIANT_NOVALUEPROP,VT_BSTR);
  11.     _tprintf(var2.bstrVal);

  13.     VariantClear(&var);
  14.     VariantClear(&var2);

  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();

  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. }
阅读(8389) | 评论(1) | 转发(2) |
0

上一篇：Unix进程间通信: 命名管道,共享内存,内存映射,消息队列

下一篇：Windows编程 线程池的具体作用

给主人留下些什么吧！~~

mengxingxia2015-05-22 10:10:32

Good for Beginner，3Q！

回复 | 举报
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6