COM---组件复用：包容与聚合

于 2017-02-16 19:05:12 发布
阅读量1.4k 收藏 4
点赞数 1
分类专栏： COM技术内幕笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012319493/article/details/55270948
版权

包容和 聚合为实现组件复用和定制提供了一种极鲁棒性的机制。使得COM框架下不需要实现继承，客户通组件的实现完全隔离开。
如果希望给组件增加新的接口，可以使用聚合。聚合是包容的一个特例。

以下代码只列出了关键部分，其它部分省略。

包容

外部组件包含指向内部组件接口的指针，此时外部组件只是内部组件的一个客户。外部组件可通过将调用转发给内部组件来重新实现内部组件的某个接口，还可在内部组件代码前后加上一些代码对接口改造。

组件1中的新成员m_pIY保存了指向所包容的组件2中IY接口的指针

外部组件

//
// Component A
//
class CA : public IX,
           public IY //@N
{
public:
    // IUnknown
    virtual HRESULT __stdcall QueryInterface(const IID& iid, void** ppv) ;
    virtual ULONG   __stdcall AddRef() ;
    virtual ULONG   __stdcall Release() ;

    // Interface IX
    virtual void __stdcall Fx() { cout << "Fx" << endl ;}

    // Interface IY
    virtual void __stdcall Fy() { m_pIY->Fy() ;} //@N

    // Constructor
    CA() ;

    // Destructor
    ~CA() ;

    // Initialization function called by the class factory
    // to create the contained component
    HRESULT __stdcall Init() ;     //@N

private:
    // Reference count
    long m_cRef ;

    // 被包容的组件
    IY* m_pIY ;
} ;


//
// Constructor
//
CA::CA()
: m_cRef(1),
  m_pIY(NULL) //@N  内部组件初始化
{
    ::InterlockedIncrement(&g_cComponents) ;
}

//
// Destructor
//
CA::~CA() 
{ 
    ::InterlockedDecrement(&g_cComponents) ; 
    trace("Destroy self.") ;

    // 释放内部组件 @N
    if (m_pIY != NULL)
    {
        m_pIY->Release() ;   
    }
}


// 创建内部组件
HRESULT __stdcall CA::Init()
{
    trace("Create contained component.") ;
    //外部组件请求了内部组件IY接口的指针，若调用成功，被保存在m_pIY中
    HRESULT hr = ::CoCreateInstance(CLSID_Component2, 
                                    NULL, 
                                    CLSCTX_INPROC_SERVER,
                                    IID_IY,
                                    (void**)&m_pIY) ;
    if (FAILED(hr))
    {
        trace("Could not create contained component.") ;
        return E_FAIL ;
    }
    else
    {
        return S_OK ;
    }
}

外部组件的类厂

//
// IClassFactory implementation
//
HRESULT __stdcall CFactory::CreateInstance(IUnknown* pUnknownOuter,
                                           const IID& iid,
                                           void** ppv) 
{
    // Cannot aggregate
    if (pUnknownOuter != NULL)
    {
        return CLASS_E_NOAGGREGATION ;
    }
    // 创建外部组件
    CA* pA = new CA ;
    if (pA == NULL)
    {
        return E_OUTOFMEMORY ;
    }
    // 创建内部组件 @N
    HRESULT hr = pA->Init() ;
    if (FAILED(hr))
    {
        // 如何失败，则删除
        pA->Release() ;
        return hr ;
    }

    // Get the requested interface.
    hr = pA->QueryInterface(iid, ppv) ;
    pA->Release() ;
    return hr ;   
}

聚合

为了实现 聚合，内部组件需要实现两个不同的接口，其中一个是非代理IUknown接口：按通常的方式实现内部组件的IUknown接口。另一个是代理接口：未被聚合时将函数调用转发给非代理接口，被聚合时转发给外部组件的IUknown接口。

聚合情况下，代理IUknown接口将调用外部组件的IUknown实现。外部组件也可以内部组件的非代理IUknown接口来控制组件的生命期。

外部组件

//
// Component A
//
class CA : public IX
        // public IY @N
{
public:
    // IUnknown
    virtual HRESULT __stdcall QueryInterface(const IID& iid, void** ppv) ;
    virtual ULONG   __stdcall AddRef() ;
    virtual ULONG   __stdcall Release() ;

    // Interface IX
    virtual void __stdcall Fx() { cout << "Fx" << endl ;}

    /* @N Component1 aggregates instead of implementing interface IY.
    // Interface IY
    virtual void __stdcall Fy() { m_pIY->Fy() ;}
    */

    // Constructor
    CA() ;

    // Destructor
    ~CA() ;

    // Initialization function called by the class factory
    // to create the contained component
    HRESULT __stdcall Init() ;  // @N

private:
    // Reference count
    long m_cRef ;

    // Pointer to the aggregated component's IY interface
    // (We do not have to retain an IY pointer. However, we
    // can use it in QueryInterface.)
    IY* m_pIY ;                 // @N

    // Pointer to inner component's IUnknown
    IUnknown* m_pUnknownInner ; // @N
} ;

//
// Destructor
// 在外部组件的析构中释放内部组件接口
CA::~CA() 
{ 
    ::InterlockedDecrement(&g_cComponents) ; 
    trace("Destroy self.") ;

    // 恢复引用计数，保证组件不会试图再次将自己释放掉
    m_cRef = 1 ;  

    // 因为对内部组件的Release将会导致对外部组件的Release调用
    IUnknown* pUnknownOuter = this ;
    pUnknownOuter->AddRef() ;

    // 将外部组件释放掉
    m_pIY->Release() ;

    // 将内部组件释放掉
    if (m_pUnknownInner != NULL)   // @N
    {
        m_pUnknownInner->Release() ;
    }
}

// 创建内部组件
HRESULT __stdcall CA::Init()
{
    // Get the pointer to the outer unknown.
    // Since this component is not aggregated, the outer unknown
    // is the same as the this pointer. 
    IUnknown* pUnknownOuter = this ;

    trace("Create inner component.") ;
    HRESULT hr =
        ::CoCreateInstance(CLSID_Component2,         
                           pUnknownOuter, // 外部组件IUnknown接口 @N
                           CLSCTX_INPROC_SERVER,
                           IID_IUnknown,  // IUnknown，当聚合时  @N
                           (void**)&m_pUnknownInner) ; 
    if (FAILED(hr))
    {
        trace("Could not create contained component.") ;
        return E_FAIL ;
    }

    //需要在创建了内部组件之后再请求其IID_IY接口
    //QueryInterface会调用AddRef，由于内部组件是被聚合的，会被转发给外部组件的AddRef
    //因此，会导致外部组件的引用计数增加，而内部组件引用计数不变
    trace("Get the IY interface from the inner component.") ;
    hr = m_pUnknownInner->QueryInterface(IID_IY, (void**)&m_pIY) ; //@N
    if (FAILED(hr))
    {
        trace("Inner component does not support interface IY.") ;
        m_pUnknownInner->Release() ;
        return E_FAIL ;
    }

    //  为了实现正确计数，因为创建内部组件会导致外部组件计数增大
    pUnknownOuter->Release() ; //@N
    return S_OK ;
}

//
// IUnknown implementation
//
HRESULT __stdcall CA::QueryInterface(const IID& iid, void** ppv)
{   
    if (iid == IID_IUnknown)
    {
        *ppv = static_cast<IUnknown*>(this) ; 
    }
    else if (iid == IID_IX)
    {
        *ppv = static_cast<IX*>(this) ;
    }
    else if (iid == IID_IY)
    {
        trace("Return inner component's IY interface.") ;
#if 1
        // 得到指向内部接口的指针
        return m_pUnknownInner->QueryInterface(iid,ppv) ; //@N
#else
        // Or you can return a cached pointer.
        *ppv = m_pIY ;   //@N
        // Fall through so it will get AddRef'ed
#endif
    }
    else
    {
        *ppv = NULL ;
        return E_NOINTERFACE ;
    }
    reinterpret_cast<IUnknown*>(*ppv)->AddRef() ;
    return S_OK ;
}

外部组件的类厂

//
// IClassFactory implementation
//
HRESULT __stdcall CFactory::CreateInstance(IUnknown* pUnknownOuter,
                                           const IID& iid,
                                           void** ppv) 
{
    // Cannot aggregate
    if (pUnknownOuter != NULL)
    {
        return CLASS_E_NOAGGREGATION ;
    }

    // Create component.
    CA* pA = new CA ;
    if (pA == NULL)
    {
        return E_OUTOFMEMORY ;
    }

    // Initialize the component. @N
    HRESULT hr = pA->Init() ;
    if (FAILED(hr))
    {
        // Initialization failed. Delete component.
        pA->Release() ;
        return hr ;
    }

    // Get the requested interface.
    hr = pA->QueryInterface(iid, ppv) ;
    pA->Release() ;
    return hr ;   
}

内部组件需要实现的接口—非代理IUknown接口

//
// 非代理 IUnknown 接口  @N
//
struct INondelegatingUnknown
{
    virtual HRESULT __stdcall
        NondelegatingQueryInterface(const IID&, void**) = 0 ;
    virtual ULONG __stdcall NondelegatingAddRef() = 0 ;
    virtual ULONG __stdcall NondelegatingRelease() = 0 ;
} ;

//
// IUnknown implementation
//
HRESULT __stdcall CB::NondelegatingQueryInterface(const IID& iid,
                                                  void** ppv)
{   
    if (iid == IID_IUnknown)
    {
        //将this指针换成了INondelegatingUnknown指针，重要！
        //保证返回的是一个非代理IUknown指针
        //当非代理接口指针查询IID_IUknown接口时，返回的将总是一个指向
        //其自身的指针。若不进行转换，返回的将是指向代理IUknown接口的指针
        *ppv = static_cast<INondelegatingUnknown*>(this) ;  // @N
    }
    else if (iid == IID_IY)
    {
        *ppv = static_cast<IY*>(this) ;
    }
    else
    {
        *ppv = NULL ;
        return E_NOINTERFACE ;
    }
    reinterpret_cast<IUnknown*>(*ppv)->AddRef() ;
    return S_OK ;
}

内部组件

//
// Component 
//
class CB : public IY,
           public INondelegatingUnknown
{
public:
    // 代理 IUnknown
    // 以内联方式实现
    // 只要将调用请求转发给外部IUknown接口或非代理IUnknown接口即可
    virtual HRESULT __stdcall
        QueryInterface(const IID& iid, void** ppv)
    {
        trace("Delegate QueryInterface.") ;
        return m_pUnknownOuter->QueryInterface(iid, ppv) ; 
    }

    virtual ULONG __stdcall AddRef() 
    {
        trace("Delegate AddRef.") ;
        return m_pUnknownOuter->AddRef() ; 
    }

    virtual ULONG __stdcall Release() 
    {
        trace("Delegate Release.") ;
        return m_pUnknownOuter->Release() ; 
    }

    // 非代理 IUnknown
    virtual HRESULT __stdcall
        NondelegatingQueryInterface(const IID& iid, void** ppv) ;
    virtual ULONG   __stdcall NondelegatingAddRef() ;
    virtual ULONG   __stdcall NondelegatingRelease() ;

    // Interface IY
    virtual void __stdcall Fy() { cout << "Fy" << endl ;}

    // Constructor
    CB(IUnknown* m_pUnknownOuter) ;

    // Destructor
    ~CB() ;

private:
    long m_cRef ;  //引用计数

    //当此组件被聚合时，指向外部IUknown接口
    IUnknown* m_pUnknownOuter ;
} ;

//
// Constructor
// 将外部IUknown的指针传给内部组件的构造函数，初始化m_pUnknownOuter
CB::CB(IUnknown* pUnknownOuter) 
: m_cRef(1)
{ 
    ::InterlockedIncrement(&g_cComponents) ; 

    //若此组件未被聚合，将m_pUnknownOuter设为指向非代理IUknown接口
    if (pUnknownOuter == NULL)
    {
        trace("Not aggregating; delegate to nondelegating IUnknown.") ;
        m_pUnknownOuter = reinterpret_cast<IUnknown*>
                          (static_cast<INondelegatingUnknown*>
                          (this)) ;
    }
    //若此组件被聚合，指向外部IUKnown接口
    else
    {
        trace("Aggregating; delegate to outer IUnknown.") ;
        m_pUnknownOuter = pUnknownOuter ;
    }
}

内部组件的类厂

//
// IClassFactory implementation
//
HRESULT __stdcall CFactory::CreateInstance(IUnknown* pUnknownOuter,
                                       const IID& iid,
                                       void** ppv)
{
    //当pUnknownOuter非空，表示外部组件想进行聚合
    //iid必须为IID_IUnknown，因为当组件被聚合时，只能返回一个IUknown接口
    if ((pUnknownOuter != NULL) && (iid != IID_IUnknown)) //@N
    {
        return CLASS_E_NOAGGREGATION ;
    }

    // Create component.
    CB* pB = new CB(pUnknownOuter) ; // @N
    if (pB == NULL)
    {
        return E_OUTOFMEMORY ;
    }

    //获取新创建的内部组件中客户所请求的接口
    //并非调用QueryInterface
    //因为类厂需要返回一个指向非代理IUknown接口的指针
    HRESULT hr = pB->NondelegatingQueryInterface(iid, ppv) ; //@N
    pB->NondelegatingRelease() ; 
    return hr ;   
}

客户

//
// Client.cpp - client implementation
//
#include <iostream.h>
#include <objbase.h>

#include "Iface.h"

void trace(const char* msg) { cout << "Client: \t" << msg << endl ;}

//
// main function
//
int main()
{
    // Initialize COM Library
    CoInitialize(NULL) ;

    trace("Get interface IX from Component 1.") ;
    IX* pIX = NULL ; 
    HRESULT hr = ::CoCreateInstance(CLSID_Component1,
                                    NULL, 
                                    CLSCTX_INPROC_SERVER,
                                    IID_IX, 
                                    (void**)&pIX) ;
    if (SUCCEEDED(hr))
    {
        trace("Succeeded creating component.") ;
        pIX->Fx() ;

        trace("Get interface IY from IX.") ;
        IY* pIY = NULL ;
        hr = pIX->QueryInterface(IID_IY, (void**)&pIY) ;
        if (SUCCEEDED(hr))
        {
            trace("Succeeded getting interface IY from IX.") ;
            pIY->Fy() ;

            trace("Get interface IX from IY.") ;
            IX* pIX2 = NULL ;
            hr = pIY->QueryInterface(IID_IX, (void**)&pIX2);
            if (SUCCEEDED(hr))
            {
                trace("Succeeded getting interface IX from IY.") ;
                pIX2->Release() ;
            }
            else
            {
                trace("Error! Should have gotten interface IX.") ;
            }

            pIY->Release() ;
        }
        else
        {
            trace("Could not get interface IY.") ;
        }

        pIX->Release() ;
    }
    else
    {
        cout << "Could not create component: " << hex << hr << endl ;
    }

    // Uninitialize COM Library
    CoUninitialize() ;

    return 0 ;
}
谛听-
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
COM接口聚合实现解惑（C++虚表）
nobugtodebug的专栏
10-12 2928
最近看潘爱民的《COM原理与应用》，看到接口的聚合实现时，产生一个疑惑。COM的这个特性的背后隐藏着一个关于C++虚表的知识点。如果对C++的虚表没有一定的认识就会被绕进去，被搞得稀里糊涂。经过和朋友的一番探讨总算搞清楚。特整理成此文我们知道支持被聚合使用的CA接口要实现一组和IUnknown接口一致的非委托Unknown接口，这一组接口完成实际的QueryInterface, AddRef
COM 的聚合
09-18 475
 今天看了一会COM的聚合 写下心得。说得有点通俗。 先说下聚合的定义：就是一个组件A只实现了IX接口，在A内部又可以使用B组建的IY接口。如果我是客户，使用组件A， 俺既可以掉IX接口，又可以掉IY接口，我可不知道有组件B的存在哦。 聚合不能象包容那样 直接转发B对IY接口的请求，因为包容A组建实现了IY：A和B共用一套QueryInterface（）；聚合就有2套QueryIn
6.COM可重用性——聚合
文洲的专栏
06-26 3707
聚合无论是原理还是实现都是COM组件中比较复杂和难以理解的地方，这里通过详细的讲解和在代码中给出详细的注释，指出常见注意点，可对比学习COM聚合技术。
COM聚合
09-01 164
COM聚合... 1 聚合的概念... 1 内部组件的实现... 2 外部组件的实现... 14 ATL7对内部组件的支持... 33 分析：... 54 DECLARE_CLASSFACTORY()宏-------------55 DECLARE_AGGREGATABLE(T)宏---------------------87 ATL7对外部组件的支持... 9...
vue-router 组件复用问题详解
08-28
Vue Router 组件复用问题详解 本文主要介绍了 Vue Router 组件复用问题详解，解决了组件复用导致路由参数失效的问题。通过了解 Vue Router 的路由机制和组件生命周期，可以实现组件内容随路由参数的变化而更新。 ...
5G-NR复用与信道编码.mht
04-16
5G-NR复用与信道编码
react-dataminrreactcomponents可复用React组件和常用函数集合
08-14
dataminr-react-components - 可复用React组件和常用函数集合
VUE element-ui 写个复用Table组件的示例代码
08-28
Vue Element-UI 复用 Table 组件示例代码 在本篇文章中，我们将讨论如何使用 Vue 和 Element-UI 库来创建一个复用的 Table 组件。该组件可以在项目中多次使用，提高开发效率和代码重用性。 1. 基本的 Table 组件 ...
COM组件聚合例子
06-29
这个一个演示COM组件的实现与调用的例子
COM 的聚合和包容
allenhiman的专栏
03-27 791
我们可以这样去认识它们 包容(Containment/Delegate)com的包容就是在自己的组件里利用别人的组件。实现这种目的的步骤很简单：如下代码HRESULT FinalConstruct() {  HRESULT hr;  hr = CoCreateInstance( CLSID_SimpleMath, NULL,          CLSCTX_INPROC_SER
包容 vs 聚合
medvision的专栏
04-17 2721
  COM特性潘爱民http://www.icst.pku.edu.cn/CompCourse内容复习:COM实现COM可重用模型 √COM跨进程模型 √COM线程模型COM安全性复习:对象创建过程客户组件创建实例对象DllGetClassObject{}创建类厂对象复习:TreeView组件的注册信息复习:类厂(Class Factory)类厂:用于创建COM对象的COM对象目标:完成COM对象
源码级 COM 组件复用的一次尝试
Nick 开发日志
12-26 1580
说到 COM 组件的复用. 那自然就是包容和聚合. 在二进制的层面上的复用. 这次我们要说的是在基于 ATL 的源代码级的复用. 比如已经有了一个 ATL 实现的组件, 比如 CComponentA, 现在想要实现另一个组件 CComponentB. 两个组件要实现的接口都相同, 比如 IComponentA. 而 CComponentB 的行为和 CComponentA 差不多, 只有个别方法的
包 容 与 聚 合
tianyu的专栏 - Linux site:blog.csdn.net/wishfly
05-13 2157
包 容 与 聚 合lostall     包容和聚合是COM中比较重要的概念，不过它们的原理还是比较简单的。     一、包容     如图所示： 图1     从上图可看出组件A自己实现了组件B的接口IB，只不过在它实现接口IB的时侯，其内部可能重用了组件B的一些代码。组件B的内部实现对client是完全隐藏的，client看见的只是IB。对client来说，接口I
COM技术内幕中聚合的实现
Meuck的专栏
06-29 2272
1.　产生的时候，会把要用到的的相关接口指针      与的指针保存下来。2. 调用的工厂方法创建，将返回一个指针。　通过得到真实的3.在产生的时候保存IUnknown接口指针,当客户调用IUnknown的接口的时候   则转接到的接口上。而真正的IUnknown的操作而在上实现4.导出后，客户在使用IUnknown还是认为在使用　因为以把相关操作转发过来了。5.在析构的时候，则调用内部组件的进行
ng-zorro-antd 自定义组件
最新发布
04-30
ng-zorro-antd 是基于 Angular 开发的一款 UI 框架，提供了丰富的基础组件和样式，可以快速开发出美观、易用的 web 应用程序。同时，ng-zorro-antd 也支持自定义组件。 首先，我们需要理解组件的基本概念。组件是 Angular 应用程序中的基本构建块，它让我们可以封装功能，将页面拆分成可复用的部分。组件通常由 HTML 模板、组件类以及样式组成。 如何自定义 ng-zorro-antd 组件呢？我们可以通过继承 ng-zorro-antd 的基础组件，并添加自己的属性和方法来实现。比如，我们可以创建一个自定义的表单组件，继承自 ng-zorro-antd 中的 Form 组件，在该组件中添加一些自定义的输入属性和方法，以便满足自己的业务需求。 同时，我们还可以利用 ng-zorro-antd 的主题机制，对组件的样式进行自定义。ng-zorro-antd 提供了一些全局样式变量，可以用来改变组件的颜色、字体等样式属性。如果需要更灵活的样式定制，可以通过创建自己的主题文件，并引入到应用程序中来实现。 最后，我们需要注意的是，在自定义 ng-zorro-antd 组件时，要遵循良好的编程习惯，包括代码可读性、可维护性和可扩展性。同时，也要考虑到组件的性能和兼容性问题，确保在不同的浏览器和设备上都能够正常运行。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值