聚合

  • 项目

聚合是一种对象重用机制，在这种机制中，外部对象将内部对象的接口公开，就好像这些接口是在外部对象上实现的一样。 当外部对象将对其接口的每次调用委派给内部对象中的相同接口时，这种方法就非常有用。 在这种情况下，聚合是为了便于避免外部对象的额外执行开销。 聚合实际上是包含/委派的一种特殊情况。

除了三个 IUnknown 函数：QueryInterface、AddRef 和 Release 之外，聚合的实现几乎与包含一样简单。 问题在于，从客户端的角度来看，外部对象上的任何 IUnknown 函数都必须影响外部对象。 也就是说，AddRef 和 Release 会影响外部对象，而 QueryInterface 则会公开外部对象上的所有可用接口。 但是，如果外部对象只是将内部对象的接口公开为自己的接口，那么通过该接口调用的内部对象 IUnknown 成员的行为将与外部对象接口上的 IUnknown 成员不同，这绝对违反了管理 IUnknown 的规则和属性。

解决方法是，聚合需要在内部对象上显式实现 IUnknown，并将任何其他接口的 IUnknown 方法委派给外部对象的 IUnknown 方法。

创建可聚合对象

创建可聚合的对象是可选的；但这样做很简单，而且能带来明显的好处。 以下规则适用于创建可聚合对象：

  • 可聚合（或内部）对象对其 IUnknown 接口的 QueryInterface、AddRef 和 Release 的实现控制着内部对象的引用计数，并且该实现不得委派给外部对象的未知对象（控制 IUnknown）。
  • 可聚合（或内部）对象对 QueryInterface、AddRef 和 Release 等接口的实现必须委派给控制 IUnknown，并且不得直接影响内部对象的引用计数。
  • 内部 IUnknown 必须仅为内部对象实现 QueryInterface。
  • 在保留对控制 IUnknown 指针的引用时，可聚合对象不得调用 AddRef。
  • 创建对象时，如果请求 IUnknown 以外的任何接口，则创建必须失败并显示 E_NOINTERFACE。

下面的代码片段说明了使用嵌套类方法实现接口的可聚合对象的正确实现：

// CSomeObject is an aggregable object that implements 
// IUnknown and ISomeInterface 
class CSomeObject : public IUnknown 
{ 
    private: 
        DWORD        m_cRef;         // Object reference count 
        IUnknown*    m_pUnkOuter;    // Controlling IUnknown, no AddRef 
 
        // Nested class to implement the ISomeInterface interface 
        class CImpSomeInterface : public ISomeInterface 
        { 
            friend class CSomeObject ; 
            private: 
                DWORD    m_cRef;    // Interface ref-count, for debugging 
                IUnknown*    m_pUnkOuter;    // Controlling IUnknown 
            public: 
                CImpSomeInterface() { m_cRef = 0;   }; 
                ~ CImpSomeInterface(void) {}; 
 
                // IUnknown members delegate to the outer unknown 
                // IUnknown members do not control lifetime of object 
                STDMETHODIMP     QueryInterface(REFIID riid, void** ppv) 
                {    return m_pUnkOuter->QueryInterface(riid,ppv);   }; 
 
                STDMETHODIMP_(DWORD) AddRef(void) 
                {    return m_pUnkOuter->AddRef();   }; 
 
                STDMETHODIMP_(DWORD) Release(void) 
                {    return m_pUnkOuter->Release();   }; 
 
                // ISomeInterface members 
                STDMETHODIMP SomeMethod(void) 
                {    return S_OK;   }; 
        } ; 
        CImpSomeInterface m_ImpSomeInterface ; 
    public: 
        CSomeObject(IUnknown * pUnkOuter) 
        { 
            m_cRef=0; 
            // No AddRef necessary if non-NULL as we're aggregated. 
            m_pUnkOuter=pUnkOuter; 
            m_ImpSomeInterface.m_pUnkOuter=pUnkOuter; 
        } ; 
        ~CSomeObject(void) {} ; 
 
        // Static member function for creating new instances (don't use 
        // new directly). Protects against outer objects asking for 
        // interfaces other than Iunknown. 
        static HRESULT Create(IUnknown* pUnkOuter, REFIID riid, void **ppv) 
        { 
            CSomeObject*        pObj; 
            if (pUnkOuter != NULL && riid != IID_IUnknown) 
                return CLASS_E_NOAGGREGATION; 
            pObj = new CSomeObject(pUnkOuter); 
            if (pObj == NULL) 
                return E_OUTOFMEMORY; 
            // Set up the right unknown for delegation (the non-
            // aggregation case) 
            if (pUnkOuter == NULL) 
            {
                pObj->m_pUnkOuter = (IUnknown*)pObj ; 
                pObj->m_ImpSomeInterface.m_pUnkOuter = (IUnknown*)pObj;
            }
            HRESULT hr; 
            if (FAILED(hr = pObj->QueryInterface(riid, (void**)ppv))) 
                delete pObj ; 
            return hr; 
        } 
 
        // Inner IUnknown members, non-delegating 
        // Inner QueryInterface only controls inner object 
        STDMETHODIMP QueryInterface(REFIID riid, void** ppv) 
        { 
            *ppv=NULL; 
            if (riid == IID_IUnknown) 
                *ppv=this; 
            if (riid == IID_ISomeInterface) 
                *ppv=&m_ImpSomeInterface; 
            if (NULL==*ppv) 
                return ResultFromScode(E_NOINTERFACE); 
            ((IUnknown*)*ppv)->AddRef(); 
            return NOERROR; 
        } ; 
        STDMETHODIMP_(DWORD) AddRef(void) 
        {    return ++m_cRef; }; 
        STDMETHODIMP_(DWORD) Release(void) 
        { 
            if (--m_cRef != 0) 
                return m_cRef; 
            delete this; 
            return 0; 
        }; 
};

聚合对象

在开发可聚合对象时，应遵循以下规则：

  • 在创建内部对象时，外部对象必须显式询问其 IUnknown。

  • 外部对象必须保护其 Release 的实现，防止重入，并围绕其销毁代码设置一个人工引用计数。

  • 如果外部对象查询指向任何内部对象接口的指针，则必须调用其控制的 IUnknownRelease 方法。 要释放此指针，外部对象会调用其控制的 IUnknownAddRef 方法，然后在内部对象的指针上调用 Release 方法。

    // Obtaining inner object interface pointer 
pUnkInner->QueryInterface(IID_ISomeInterface, &pISomeInterface); 
pUnkOuter->Release(); 

// Releasing inner object interface pointer 
pUnkOuter->AddRef(); 
pISomeInterface->Release();

  • 外部对象不得盲目地将任何未识别接口的查询委派给内部对象，除非该行为是外部对象的明确意图。

包含/委派