COM连接点 - Part II - 最简单的例子 (1)

最新推荐文章于 2021-09-30 16:39:18 发布
最新推荐文章于 2021-09-30 16:39:18 发布
阅读量2.3k 收藏 4
点赞数
分类专栏： COM 文章标签： COM Windows 7

From: http://blog.csdn.net/zj510/article/details/39056097

 

连接点，connection point，在COM里面也是挺重要的。简单讲，COM里面的连接点就好像是C语言的回调函数，只不过它是基于面向对象实现的。连接点的作用也就是COM对象将一些事件通知客户（调用者）。


先来做一个简单的连接点例子吧，之后再慢慢探讨。

用ATL创建一个工程（DLL COM)，取名MyCom，

然后创建一个COM接口，IMyCar. 在options那里选上connection points。

然后在class view那里找到_IMyCarEvents(在MyComLib下面),右键点击Add Method.如图，增加一个方法OnStop。

增加完之后，可以看到IDL文件里面多了个方法，如下图：

[cpp] view plain copy print ?
  1. library MyComLib 
  2. { 
  3.     importlib("stdole2.tlb"); 
  4.     [ 
  5.         uuid(2CF347A8-63ED-4CE0-8A6D-F98D60C98B8C)       
  6.     ] 
  7.     dispinterface _IMyCarEvents 
  8.     { 
  9.         properties: 
  10.         methods: 
  11.              
  12.             [id(1)] HRESULT OnStop([in] FLOAT Distance); 
  13.     }; 
  14.     [ 
  15.         uuid(DA6770F3-CBB6-4F34-A137-2B02A27AB219)       
  16.     ] 
  17.     coclass MyCar 
  18.     { 
  19.         [default] interface IMyCar; 
  20.         [default, source] dispinterface _IMyCarEvents; 
  21.     }; 
  22. };  
library MyComLib
{
	importlib("stdole2.tlb");
	[
		uuid(2CF347A8-63ED-4CE0-8A6D-F98D60C98B8C)		
	]
	dispinterface _IMyCarEvents
	{
		properties:
		methods:
            
            [id(1)] HRESULT OnStop([in] FLOAT Distance);
    };
	[
		uuid(DA6770F3-CBB6-4F34-A137-2B02A27AB219)		
	]
	coclass MyCar
	{
		[default] interface IMyCar;
		[default, source] dispinterface _IMyCarEvents;
	};
};


 

之后在CMyCar上点击右键，选择Add Connection Point。

选择_IMyCarEvents，点击>按钮。然后Finish.

这样，我们就增加了一个连接点，在CProxy_IMyCarEvents里面可以看到多了个函数。如下

[cpp] view plain copy print ?
  1. #pragma once 
  2.  
  3. template<class T> 
  4. class CProxy_IMyCarEvents : 
  5.     public ATL::IConnectionPointImpl<T, &__uuidof(_IMyCarEvents)> 
  6. { 
  7. public: 
  8.     HRESULT Fire_OnStop(FLOAT Distance) 
  9.     { 
  10.         HRESULT hr = S_OK; 
  11.         T * pThis = static_cast<T *>(this); 
  12.         int cConnections = m_vec.GetSize(); 
  13.  
  14.         for (int iConnection = 0; iConnection < cConnections; iConnection++) 
  15.         { 
  16.             pThis->Lock(); 
  17.             CComPtr<IUnknown> punkConnection = m_vec.GetAt(iConnection); 
  18.             pThis->Unlock(); 
  19.  
  20.             IDispatch * pConnection = static_cast<IDispatch *>(punkConnection.p); 
  21.  
  22.             if (pConnection) 
  23.             { 
  24.                 CComVariant avarParams[1]; 
  25.                 avarParams[0] = Distance; 
  26.                 avarParams[0].vt = VT_R4; 
  27.                 CComVariant varResult; 
  28.  
  29.                 DISPPARAMS params = { avarParams, NULL, 1, 0 }; 
  30.                 hr = pConnection->Invoke(1, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, ¶ms, &varResult, NULL, NULL); 
  31.             } 
  32.         } 
  33.         return hr; 
  34.     } 
  35. };  
#pragma once

template<class T>
class CProxy_IMyCarEvents :
	public ATL::IConnectionPointImpl<T, &__uuidof(_IMyCarEvents)>
{
public:
	HRESULT Fire_OnStop(FLOAT Distance)
	{
		HRESULT hr = S_OK;
		T * pThis = static_cast<T *>(this);
		int cConnections = m_vec.GetSize();

		for (int iConnection = 0; iConnection < cConnections; iConnection++)
		{
			pThis->Lock();
			CComPtr<IUnknown> punkConnection = m_vec.GetAt(iConnection);
			pThis->Unlock();

			IDispatch * pConnection = static_cast<IDispatch *>(punkConnection.p);

			if (pConnection)
			{
				CComVariant avarParams[1];
				avarParams[0] = Distance;
				avarParams[0].vt = VT_R4;
				CComVariant varResult;

				DISPPARAMS params = { avarParams, NULL, 1, 0 };
				hr = pConnection->Invoke(1, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, ¶ms, &varResult, NULL, NULL);
			}
		}
		return hr;
	}
};


现在来看看怎么使用这个连接点吧。

先个IMyCar增加一个方法，

[cpp] view plain copy print ?
  1. STDMETHODIMP CMyCar::Run() 
  2. { 
  3.     // TODO: Add your implementation code here 
  4.  
  5.     this->Fire_OnStop(1000); 
  6.  
  7.     return S_OK; 
  8. }  
STDMETHODIMP CMyCar::Run()
{
    // TODO: Add your implementation code here

    this->Fire_OnStop(1000);

    return S_OK;
}


然后写个客户程序，如下：

[cpp] view plain copy print ?
  1. // TestCom.cpp : Defines the entry point for the console application. 
  2. // 
  3.  
  4. #include "stdafx.h" 
  5. #include <atlbase.h> 
  6. #include <atlcom.h> 
  7. #include "../MyCOM/MyCOM_i.h" 
  8. #include "../MyCOM/MyCOM_i.c" 
  9.  
  10. #include <iostream> 
  11. #include <thread> 
  12.  
  13.  
  14. using namespace std; 
  15.  
  16. class CSink : 
  17.     public CComObjectRoot, 
  18.     public _IMyCarEvents 
  19. { 
  20.     BEGIN_COM_MAP(CSink) 
  21.         COM_INTERFACE_ENTRY(IDispatch) 
  22.         COM_INTERFACE_ENTRY(_IMyCarEvents) 
  23.     END_COM_MAP() 
  24.  
  25. public: 
  26.     virtual ~CSink(){} 
  27.     STDMETHODIMP GetTypeInfoCount(UINT *pctinfo) { return E_NOTIMPL; } 
  28.     STDMETHODIMP GetTypeInfo(UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)   { return E_NOTIMPL; } 
  29.     STDMETHODIMP GetIDsOfNames(REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)  { return E_NOTIMPL; } 
  30.  
  31.     STDMETHODIMP Invoke(DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr) 
  32.     { 
  33.         printf("sink, id: %d, parm: %f", dispIdMember, pDispParams->rgvarg[0].fltVal); 
  34.  
  35.         return S_OK; 
  36.     } 
  37. }; 
  38.  
  39.  
  40. CComModule m_commodule; 
  41.  
  42. int _tmain(int argc, _TCHAR* argv[]) 
  43. { 
  44.     CoInitializeEx(0, COINIT_APARTMENTTHREADED); 
  45.  
  46.     { 
  47.         CComPtr<IMyCar> spCar; 
  48.         spCar.CoCreateInstance(CLSID_MyCar, NULL, CLSCTX_INPROC_SERVER); 
  49.  
  50.         CComObject<CSink>* sinkptr = nullptr; 
  51.         CComObject<CSink>::CreateInstance(&sinkptr); 
  52.  
  53.         DWORD cookies = 0; 
  54.  
  55.         AtlAdvise(spCar, sinkptr, __uuidof(_IMyCarEvents), &cookies); 
  56.  
  57.         spCar->Run(); 
  58.     } 
  59.      
  60.  
  61.     CoUninitialize(); 
  62.  
  63.  
  64.     return 0; 
  65. }  
// TestCom.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <atlbase.h>
#include <atlcom.h>
#include "../MyCOM/MyCOM_i.h"
#include "../MyCOM/MyCOM_i.c"

#include <iostream>
#include <thread>


using namespace std;

class CSink :
    public CComObjectRoot,
    public _IMyCarEvents
{
    BEGIN_COM_MAP(CSink)
        COM_INTERFACE_ENTRY(IDispatch)
        COM_INTERFACE_ENTRY(_IMyCarEvents)
    END_COM_MAP()

public:
    virtual ~CSink(){}
    STDMETHODIMP GetTypeInfoCount(UINT *pctinfo) { return E_NOTIMPL; }
    STDMETHODIMP GetTypeInfo(UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)   { return E_NOTIMPL; }
    STDMETHODIMP GetIDsOfNames(REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)  { return E_NOTIMPL; }

    STDMETHODIMP Invoke(DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
    {
        printf("sink, id: %d, parm: %f", dispIdMember, pDispParams->rgvarg[0].fltVal);

        return S_OK;
    }
};


CComModule m_commodule;

int _tmain(int argc, _TCHAR* argv[])
{
	CoInitializeEx(0, COINIT_APARTMENTTHREADED);

    {
        CComPtr<IMyCar> spCar;
        spCar.CoCreateInstance(CLSID_MyCar, NULL, CLSCTX_INPROC_SERVER);

        CComObject<CSink>* sinkptr = nullptr;
        CComObject<CSink>::CreateInstance(&sinkptr);

        DWORD cookies = 0;

        AtlAdvise(spCar, sinkptr, __uuidof(_IMyCarEvents), &cookies);

        spCar->Run();
    }
    

	CoUninitialize();


	return 0;
}

跑一下，发现CSink里面的invoke被调用到了。

这样，我们就有了一个简单的连接点例子。其中pDispParams->rgvarg[0].fltVal就是COM对象触发这个连接点的时候传进来的参数1000.


Sink类

其实，这个东西比较固定，反正新手那么写就行了。其他的都可以忽略，主要就是Invoke函数，当COM对象fire一个事件的时候，Invoke函数会被调用。然后在这个函数里面处理可以获取事件的id：dispIdMember以及参数。这样调用者，也就是事件的接收者就可以处理这些事件了，并且返回结果。

如何创建和挂载sink

首先，我们需要创建一个sink实例。就通过下面2行。先声明一个null指针，然后调用CComObject<CSink>::CreateInstance来创建一个sink对象。等CreateInstance返回后，成功的话，sinkptr就指向一个CComSink<CSink>对象。

[cpp] view plain copy print ?
  1. CComObject<CSink>* sinkptr = nullptr; 
  2. CComObject<CSink>::CreateInstance(&sinkptr);  
        CComObject<CSink>* sinkptr = nullptr;
        CComObject<CSink>::CreateInstance(&sinkptr);

然后将这个sink对象挂载到对应的COM对象上。下面的2行代码就是将sinkptr挂载到spCar对象上面。cookies的作用查看MSDN.简单讲cookies是一个传出参数，代表这次挂载，这个值是唯一的。如果想取消这个挂载，就可以用这个cookies和AtlUnadvise来取消连接。

[cpp] view plain copy print ?
  1. DWORD cookies = 0; 
  2. AtlAdvise(spCar, sinkptr, __uuidof(_IMyCarEvents), &cookies);  
        DWORD cookies = 0;
        AtlAdvise(spCar, sinkptr, __uuidof(_IMyCarEvents), &cookies);

细心一点的同学可能会问，这个地方是不是有个内存泄漏？
sinkptr指向了一个CComObject<CSink>对象，然后sinkptr本身死亡前又没有释放，那岂不是内存泄漏？

这是个很好的问题，我们先看一下AtlAdvise的实现：

[cpp] view plain copy print ?
  1. ATLINLINE ATLAPI AtlAdvise( 
  2.     _Inout_ IUnknown* pUnkCP, 
  3.     _Inout_opt_ IUnknown* pUnk, 
  4.     _In_ const IID& iid, 
  5.     _Out_ LPDWORD pdw) 
  6. { 
  7.     if(pUnkCP == NULL) 
  8.         return E_INVALIDARG; 
  9.  
  10.     CComPtr<IConnectionPointContainer> pCPC; 
  11.     CComPtr<IConnectionPoint> pCP; 
  12.     HRESULT hRes = pUnkCP->QueryInterface(__uuidof(IConnectionPointContainer), (void**)&pCPC); 
  13.     if (SUCCEEDED(hRes)) 
  14.         hRes = pCPC->FindConnectionPoint(iid, &pCP); 
  15.     if (SUCCEEDED(hRes)) 
  16.         hRes = pCP->Advise(pUnk, pdw); 
  17.     return hRes; 
  18. }  
ATLINLINE ATLAPI AtlAdvise(
	_Inout_ IUnknown* pUnkCP,
	_Inout_opt_ IUnknown* pUnk,
	_In_ const IID& iid,
	_Out_ LPDWORD pdw)
{
	if(pUnkCP == NULL)
		return E_INVALIDARG;

	CComPtr<IConnectionPointContainer> pCPC;
	CComPtr<IConnectionPoint> pCP;
	HRESULT hRes = pUnkCP->QueryInterface(__uuidof(IConnectionPointContainer), (void**)&pCPC);
	if (SUCCEEDED(hRes))
		hRes = pCPC->FindConnectionPoint(iid, &pCP);
	if (SUCCEEDED(hRes))
		hRes = pCP->Advise(pUnk, pdw);
	return hRes;
}

我们可以看到pUnk被传到了pCP->Advise(pUnk, pdw);里面。再看看相关代码：

[cpp] view plain copy print ?
  1. template <class T, const IID* piid, class CDV> 
  2. IConnectionPointImpl<T, piid, CDV>::~IConnectionPointImpl() 
  3. { 
  4.     IUnknown** pp = m_vec.begin(); 
  5.     while (pp < m_vec.end()) 
  6.     { 
  7.         if (*pp != NULL) 
  8.             (*pp)->Release(); 
  9.         pp++; 
  10.     } 
  11. } 
  12.  
  13. template <class T, const IID* piid, class CDV> 
  14. STDMETHODIMP IConnectionPointImpl<T, piid, CDV>::Advise( 
  15.     _Inout_ IUnknown* pUnkSink, 
  16.     _Out_ DWORD* pdwCookie) 
  17. { 
  18.     T* pT = static_cast<T*>(this); 
  19.     IUnknown* p; 
  20.     HRESULT hRes = S_OK; 
  21.     if (pdwCookie != NULL) 
  22.         *pdwCookie = 0; 
  23.     if (pUnkSink == NULL || pdwCookie == NULL) 
  24.         return E_POINTER; 
  25.     IID iid; 
  26.     GetConnectionInterface(&iid); 
  27.     hRes = pUnkSink->QueryInterface(iid, (void**)&p); 
  28.     if (SUCCEEDED(hRes)) 
  29.     { 
  30.         pT->Lock(); 
  31.         *pdwCookie = m_vec.Add(p); 
  32.         hRes = (*pdwCookie != NULL) ? S_OK : CONNECT_E_ADVISELIMIT; 
  33.         pT->Unlock(); 
  34.         if (hRes != S_OK) 
  35.             p->Release(); 
  36.     } 
  37.     else if (hRes == E_NOINTERFACE) 
  38.         hRes = CONNECT_E_CANNOTCONNECT; 
  39.     if (FAILED(hRes)) 
  40.         *pdwCookie = 0; 
  41.     return hRes; 
  42. }  
template <class T, const IID* piid, class CDV>
IConnectionPointImpl<T, piid, CDV>::~IConnectionPointImpl()
{
	IUnknown** pp = m_vec.begin();
	while (pp < m_vec.end())
	{
		if (*pp != NULL)
			(*pp)->Release();
		pp++;
	}
}

template <class T, const IID* piid, class CDV>
STDMETHODIMP IConnectionPointImpl<T, piid, CDV>::Advise(
	_Inout_ IUnknown* pUnkSink,
	_Out_ DWORD* pdwCookie)
{
	T* pT = static_cast<T*>(this);
	IUnknown* p;
	HRESULT hRes = S_OK;
	if (pdwCookie != NULL)
		*pdwCookie = 0;
	if (pUnkSink == NULL || pdwCookie == NULL)
		return E_POINTER;
	IID iid;
	GetConnectionInterface(&iid);
	hRes = pUnkSink->QueryInterface(iid, (void**)&p);
	if (SUCCEEDED(hRes))
	{
		pT->Lock();
		*pdwCookie = m_vec.Add(p);
		hRes = (*pdwCookie != NULL) ? S_OK : CONNECT_E_ADVISELIMIT;
		pT->Unlock();
		if (hRes != S_OK)
			p->Release();
	}
	else if (hRes == E_NOINTERFACE)
		hRes = CONNECT_E_CANNOTCONNECT;
	if (FAILED(hRes))
		*pdwCookie = 0;
	return hRes;
}

我们可以看到pUnkSink被放到了m_vec里面(当然，如果中间过程出错的话，直接被release了）。然后在析构函数里面，我们可以看到m_vec里面的所有元素都会调用release来释放。

而spCar的实现类CMyCar有个基类叫做CProxy_IMyCarEvents，CProxy_IMyCarEvents有个基类是IConnectionPointImpl。

那么当spCar在析构的时候，自然就会调用IConnectionPointImpl的析构函数。也就是说会把所有sink对象全部释放掉。

换句话说，一旦将sink对象成功挂载到了COM对象，那么sink对象的生命周期就由对应的COM对象来管理。

我们可以做个简单测试，在上面的例子代码里面，当spCar析构的时候，也就是代码要跑出大括号（spCar->Run();下面）的时候，sink对象也应该被释放。跟了一把，确实是这样。


ok，我们现在不用再担心内存泄漏问题了。一旦挂载成功，sink对象就托管给对应的COM对象了，如果对应的COM对象析构了，那么所有它管理的sink对象也就释放了。

上面的例子，其实很傻，它的主要过程是：

1. 创建sink对象

2. 挂载sink对象到一个COM对象上

3. COM对象调用Run函数

4. Run函数内部触发了一个连接点

5. 调用者的对应函数会被调用，这里是Invoke。

细细看上面的例子，其实Invoke是在Run函数中被调用的。这个好像没有什么意义。真正的回调应该是调用者调用完之后做其他事情了，然后等有回调来的时候，对应的函数会被触发。

anyway，本文中的例子是个非常简单的例子，只是为了展示一个连接点。连接点的威力根本没有发挥，至于真正的连接点应该怎样？待续。。。

 

妖精的配角
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
ATL_COM组件开发，多线程中应用连接点传递消息实例
09-12
本程序使用的是ATL-COM支持连接点的模式。其中反映了Observer的支持。使用多线程调用Fire函数。
ATL中连接到连接点对象的实现
Phil.Z's Program Blog
01-22 2112
     这篇文章并不是用来描述如何用ATL来开发一个带有连接点的COM组件，而是用来描述如何创建一个组件连接到某个COM组件的连接点上。如果要了解带连接点的COM组件的开发方法可以参考《ATL开发指南》和《深入解析ATL》当中的相关章节。连接到带连接点的COM组件的这些组件主要要完成的功能有两种：第一是异步调用，假设带有连接点的某个组件A有一个方法func1，func1的运算需要耗费大量的时间或
COM连接点 - 最简单的例子 (1)
热门推荐
zj510的专栏
09-04 1万+
先创建一个COM接口，IMyCar
COM组件的接口类添加Event
丸子头的专栏
04-19 1614
自己获取有无event的区别是，在向导中是否勾选：连接点。 红色为添加部分： import "oaidl.idl"; import "ocidl.idl";   [      object,      uuid(C74F7F62-D315-4BF6-9422-9B80D68DB4FA),      dual,      nonextensibl
COM connect point server建立步骤
joinpark的专栏
09-30 126
VS2019，新建ATL project. 名字ATLFindServer 在解决方案资源管理器里右键ATLFindServer工程，添加新项目 选择ATL 简单对象ATLFindObject，创建在启动里面，勾选“连接点” 在类视图里，接口IATLFindObject右键添加方法FindObject，参数BSTR name，如下图： 在ATLFindServer.idl中IATLFIndObjectEvents中添加NotifyFindObject函数 然后再_IATL
高强度螺栓连接系统计算-多螺栓连接 VDI2230-Part 02.pdf
最新发布
06-13
高强度螺栓连接系统计算-多螺栓连接 VDI2230-Part 02.pdf
官方OPC UA标准规范Part1-part14全部部分
07-14
1. **Part 1: Architecture** - 这一部分定义了OPC UA的整体架构，包括其服务模型、信息模型和通信模型。它描述了OPC UA服务器和客户端如何通过服务接口交互，并解释了信息模型的概念，这是OPC UA的核心部分。 2. *...
Graphonomy Pascal-Person-Part trained model
03-25
Graphonomy Pascal-Person-Part trained model, https://github.com/Gaoyiminggithub/Graphonomy
OPC-UA 规范（含全部part1-part13）
04-09
1. **OPC-UA Part 1 - 基础与概念**：这部分介绍了OPC UA的基本原理和架构，包括服务、信息模型、地址空间、安全模型等核心概念。 2. **OPC-UA Part 3 - 地址空间模型**：这部分定义了如何在OPC UA服务器中组织和...
SD-UHS-II简化规范中文完整翻译.pdf
12-09
SD-UHS-II简化规范中文完整翻译 附件是风语者对SD Specifications Part 1 UHS-II Simplified Addendum Version 1.02文档的翻译
ATL-连接点和接口方法的使用
谢绝留言与私信
04-20 3090
前言在做COMDLL， 用MFC测试程序插入注册好的ATL控件. 测试连接点的添加， 控件方法的添加，测试程序被控件调用连接点函数, 测试程序去调用控件的接口方法.效果图工程下载点srcUserLoginComControl.zip 编译环境 : vc6sp6 + win7x64 + ATL(复合控件) + MFC(测试程序)工程预览COMDLL// MyLoginControl.idl : I
OLE技术专题——第四讲：COM的连接点事件（上）
feijj2002_的专栏
09-02 3106
作者：杨老师一、前言　　我的 COM 组件运行时产生一个窗口，当用户双击该窗口的时候，我需要通知调用者；　　我的 COM 组件用线程方式下载网络上的一个文件，当我完成任务后，需要通知调用者；　　我的 COM 组件完成一个钟表的功能，当预定时间到达的时候，我需要通知调用者；　　... ... ... ...　　本回书开始话说 COM 的事件、通知、连接点......这些内容比较多，我分两次（共四回）
COM 连接点事件讲解
步入什么
12-12 3662
开发环境：VC++6.0测试环境:windows 2000 这篇文章是Alex C. Punnen.所写，在http://www.codeguru.com/上发表的，在此本人将其翻译成中文，和大家共享。 （注：本人翻译不当之处，还请各位多指正和谅解）运行环境：Windows 2000 Server, Microsoft Visual C++ 6此篇文章将用一个清晰的例子来描述COM中连
COM连接点事件event
丸子头的专栏
04-21 4216
COM 中的典型方案是让客户端对象实例化服务器对象，然后调用这些对象。然而，没有一种特殊机制的话，这些服务器对象将很难转向并回调到客户端对象。COM 连接点便提供了这种特殊机制，实现了服务器和客户端之间的双向通信。使用连接点，服务器能够在服务器上发生某些事件时调用客户端。 有了连接点，服务器可通过定义一个接口来指定它能够引发的事件。服务器上引发事件时，要采取操作的客户端会向服务器
OLE技术专题——COM连接点事件（下）
feijj2002_的专栏
09-02 3190
Understanding COM Event HandlingBy Lim Bio Liong Change of Article TitlePlease note that I have changed the title of this article from "TEventHandler - A C++ COM Event Handler For IDispatch-Based Even
初识统一事件模型之COM连接点
optman的专栏
06-06 2306
学习C#的时候，最喜欢的就是event关键字，因为事件处理变得很轻松。以往在C++里，我们一般是使用回调函数或者虚函数（接口），虽然也挺方便，但是如果有多个事件接收者就比较麻烦了，而且每个人实现的回调方式都不一样。在COM编程模型里的连接点也很好，允许多个事件接收者，甚至利用COM的机制跨进程回调通知，可惜实现太负责，调用也麻烦。最好还是像C#的event关键字，清晰明了。在尝试使用Attribu
VC编写COM连接点事件
深之JohnChen的专栏
07-12 1万+
VC编写COM连接点事件   COM 中的典型方案是让客户端对象实例化服务器对象，然后调用这些对象。然而，没有一种特殊机制的话，这些服务器对象将很难转向并回调到客户端对象。COM 连接点便提供了这种特殊机制，实现了服务器和客户端之间的双向通信。使用连接点，服务器能够在服务器上
COM连接点 - 基本原理(2)
zj510的专栏
09-05 3991
这次我们来看一下连接点的基本工作y
COM组件设计与应用（十五）
weixin_33696106的博客
10-14 135
COM组件设计与应用（十五）连接点(vc6.0)作者：杨老师 下载源代码一、前言　　上回书介绍了回调接口，在此基础上，我们理解连接点就容易多了。二、原理图一、连接点组件原理图。左侧为客户端，右侧为服务端（组件对象）　　看着好复杂呀......呵呵，其实简单的紧：（注1）1、一个 COM 组件，允许有多个连接点对象(IConnectionPoint)。   也就是说可以有多个发生“事件”的源头。上...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值