即AddRef和Release方法.用这两个方法可以有效的管理组件的生命周期。

AddRef则计数加1

Release则计数减1,若等于0则释放资源

interface IUnknown
{
    virtual HRESULT __stdcall QueryInterface(const IID& iid, void** ppv) =0;            
    virtual ULONG __stdcall AddRef() =0 ;
    virtual ULONG __stdcall Release() =0 ;
};

一.引用计数三大规则

1.在返回接口指针时调用AddRef.

IUnknown* CreateInstance()
{
    IUnknown* pI = static_cast<IX*>(new CA) ;
    pI->AddRef() ;
    return pI ;
}

2.在使用完接口时调用Release.用户很懒，总是想让系统自己释放资源,但只有用户自己才知道什么时候不需要使用了.还得用户自己来调

记得接口用完后调用Release

如下代码

int main()
{
    HRESULT hr ;

    trace("Client: Get an IUnknown pointer.") ;
    IUnknown* pIUnknown = CreateInstance() ;


    trace("Client: Get interface IX.") ;

    IX* pIX = NULL ; 
    hr = pIUnknown->QueryInterface(IID_IX, (void**)&pIX) ;

    if (SUCCEEDED(hr))
    {
        trace("Client: Succeeded getting IX.") ;
        pIX->Fx() ;          // Use interface IX.
        pIX->Release() ;
    }


    trace("Client: Get interface IY.") ;

    IY* pIY = NULL ;
    hr = pIUnknown->QueryInterface(IID_IY, (void**)&pIY) ;
    if (SUCCEEDED(hr))
    {
        trace("Client: Succeeded getting IY.") ;
        pIY->Fy() ;          // Use interface IY.
        pIY->Release() ;
    }


    trace("Client: Ask for an unsupported interface.") ;

    IZ* pIZ = NULL ;
    hr = pIUnknown->QueryInterface(IID_IZ, (void**)&pIZ) ;
    if (SUCCEEDED(hr))
    {
        trace("Client: Succeeded in getting interface IZ.") ;
        pIZ->Fz() ;
        pIZ->Release() ;
    }
    else
    {
        trace("Client: Could not get interface IZ.") ;
    }


    trace("Client: Release IUnknown interface.") ;
    pIUnknown->Release() ;

    return 0;
}

3.在赋值后调用AddRef.

pIX->Fx() ;          // Use interface IX.
IX* pIX2=pIX;
pIX2->AddRef();
pIX2->Fx();
pIX2->Release() ;
pIX->Release() ;

二.引用计数接口单一维护

上面我们可以看到,每个引用计数接口都是单一维护,很麻烦.

为何不在同一个组件统一维护呢?解释是为了方便后续调试和资源的释放.等接口多了就很难管理,万一是全局设计,就很难找出是哪个接口的问题了.(我感觉这完全是设计问题,但确实是个问题)

三.引用计数的实现

返回值供调试使用，其他地方意义不大。

ULONG __stdcall CA::AddRef()
{
    cout << "CA:     AddRef = " << m_cRef+1 << '.' << endl ;
    return InterlockedIncrement(&m_cRef) ;
}

ULONG __stdcall CA::Release() 
{
    cout << "CA:     Release = " << m_cRef-1 << '.' << endl ;

    if (InterlockedDecrement(&m_cRef) == 0)
    {
        delete this ;
        return 0 ;
    }
    return m_cRef ;
}

到此为止,用户的使用从直接用delete关键字变成用Release释放资源.

四.何时进行引用计数

1.若生命周期包含，可以省却引用计数

pIX->Fx() ;          // Use interface IX.
IX* pIX2=pIX;
pIX2->AddRef();
pIX2->Fx();
pIX2->Release() ;
pIX->Release() ;

2.生命周期不包含则无法省却

顺序换一下就大不一样了.

IX* pIX2=pIX;
 pIX->Fx() ;
 pIX2->AddRef();
 pIX->Release() ;
 pIX2->Fx();
 pIX2->Release() ;

五.引用计数规则

下次继续

一.COM接口的开始IUnknown

com起于接口，又归于接口.

com之所以是com,是因为其继承了一个名为IUnknown接口.

IUnknown接口是一个非常有趣的名字.我们第一次看到这个接口,都会非常好奇,名字的由来开发内部肯定是有故事的,或者他们想不出啥好名字也是有可能的.

下面我们来看一下IUnknown接口定义了哪些成员,这篇只讲QueryInterface

interface IUnknown
{
    virtual HRESULT __stdcall QueryInterface(const IID& iid, void** ppv) =0;            
    virtual ULONG __stdcall AddRef() =0 ;
    virtual ULONG __stdcall Release() =0 ;
};

二.QueryInterface的实现与使用

1.作用

看命名就可以猜这个方法是用来查询组件是否支持某个特定接口。若支持泽返回指向此接口的指针。

2.参数

QueryInterface方法有两个参数,

第一个为接口标识符,简称IID,全名(Interface Identifier),现在可以只理解为一个常量

第二个参数即为返回的接口指针

3.使用方法

我们先来看示例代码

定义一个继承自IUnknown接口的IX

interface IX : IUnknown
{
    virtual void __stdcall Fx() = 0 ;
} ;

若CA实现了该IX接口,则使用如下

static const IID IID_IX = 
    {0x32bb8320, 0xb41b, 0x11cf,
    {0xa6, 0xbb, 0x0, 0x80, 0xc7, 0xb2, 0xd6, 0x82}} ;

void foo(IUnknown* pI)
{
    IX* pIX=NULL;
    HRESULT hr=pI->QueryInterface(IID_IX,(void**)&pIX);

    if(SUCCEEDED(hr)
    {
       pIX->Fx();
    }
}

3.1 HRESULT

HRESULT是一个查询结果状态集合，并非true或false可以表示的，所以用SUCCEEDED方法来判断查询结果是否成功，失败的话，接口指针为NULL.

4.QueryInterface的实现

CA继承了IX，由于IX继承了IUnknown接口，所以CA也必须实现IUnknown接口成员,我们重新来看一下QueryInterface方法的参数

virtual HRESULT __stdcall QueryInterface(const IID& iid, void** ppv) =0;

该方法会根据传输不同iid,而返回相对应的接口指针,为了演示，我们再定义一个接口IY,CA实现IX和IY，

如下实现

HRESULT __stdcall CA::QueryInterface(const IID& iid, void** ppv)
{     
    if (iid == IID_IUnknown)
    {
        *ppv = static_cast<IX*>(this) ;
    }
    else if (iid == IID_IX)
    {
        *ppv = static_cast<IX*>(this) ;
    }
    else if (iid == IID_IY)
    {
        *ppv = static_cast<IY*>(this) ;
    }
    else
    {         
        *ppv = NULL ;
        return E_NOINTERFACE;
    }
    return S_OK ;
}

是不是很简单？,获取到以后用static_cast来转换类型。IID_IUnknown,S_OK，E_NOINTERFACE等都是内置的状态码

5.简单创建IUnknown

IUnknown* CreateInstance()
{
    IUnknown* pI = static_cast<IX*>(new CA) ;
    pI->AddRef() ;
    return pI ;
}

6.调用接口

int main()
{
    HRESULT hr ;    
    IUnknown* pIUnknown = CreateInstance() ;
   
    IX* pIX = NULL ; 
    hr = pIUnknown->QueryInterface(IID_IX, (void**)&pIX) ;
    if (SUCCEEDED(hr))
    {
        pIX->Fx() ;          // Use interface IX.
    }

    IY* pIY = NULL ;
    hr = pIUnknown->QueryInterface(IID_IY, (void**)&pIY) ;
    if (SUCCEEDED(hr))
    {
        pIY->Fy() ;          // Use interface IY.
    }

    // Delete the component.
    delete pIUnknown ;
    return 0 ;
}

三.QueryInterface实现准则

1.QueryInterface返回的总是同一IUnknown指针,贴图了

2.若用户曾获取过某个接口，那么它将总能获取此接口

3.用户可获取再次获取过的接口

4.用户可以返回到起始接口

3和4都可以理解为接口之间的切换。

5.接口可获取-获取到接口的接口

通过A接口得到B接口，B接口可以获取C接口，那么A接口可以直接获取C接口．

以上就如数学公式一般，犹如com编程的不变真理．

所以学习的资料则是

1. com技术内幕
2. com本质论
3. com原理与应用

一.c++接口的实现

c++没有接口概念，只有抽象类.

1.定义接口(纯抽象类)

如下,用virtual关键字表明该方法为抽象方法,未实现的方法后面+ =0

class IX
{
public:
    virtual void Fx1() = 0 ;
    virtual void Fx2() = 0 ;
} ;

2.实现接口

类可以多重继承,但为了简单,所以就用一个接口.

class CA : public IX{
public:
    // Implement interface IX.
    virtual void Fx1() {cout << "CA::Fx1" << endl ;}
    virtual void Fx2() {cout << "CA::Fx2" << endl ;}
}

到这里为止跟com一点关系都没有的.

二.接口定义的简化(伪纯抽象类)

由于c++并无interface关键字,为了编码约定,可以用#define关键字定义,将类改成接口.

#define interface struct

现在我们可以重新定义IX,注意此处不用把方法标记为public,struct默认把成员公开.这样就简化了接口的定义

如下

interface IX
{
    virtual void Fx1() = 0 ;
    virtual void Fx2() = 0 ;
} ;

这样是不是很简单了?

三.标准调用

由于c++编译器各不同,方法的调用方式各有不同,可先参考这里.

微软平台的com接口大部分(即推荐用法,话不敢说死,所以无需纠缠)均采用__stdcall这种标准调用约定

现在为每个方法加上__stdcall调用约定,如下代码

interface IX
{
    virtual void __stdcall Fx1() = 0 ;
    virtual void __stdcall Fx2() = 0 ;
} ;

当然具体实现的类,也需要改变,如下代码

class CA : public IX{
public:
    virtual void __stdcall Fx1() {cout << "CA::Fx1" << endl ;}
    virtual void __stdcall Fx2() {cout << "CA::Fx2" << endl ;}
}

定义好接口和实现这些接口后，我们接下就是要使用这些接口

四.调用接口

int main()
{
    CA* pA = new CA ;
    // Get an IX pointer.
    IX* pIX = pA ;
    pIX->Fx1() ;
    pIX->Fx2() ;
    delete pA ;
    return 0 ;
}

到目前为止,跟com组件根本搭不上边.我们且称这是一个组件(中间件,类库…)都可以.

五.虚拟函数表vtbl(virtual function table)

1.虽然com接口号称语言,无关性,为何我们还是选择c++作为编写的语言,而不是c#或者java?

2.c++抽象基类怎么说成是com接口?

我们先重新来看那段接口的代码.

interface IX
{
    virtual void __stdcall Fx1() = 0 ;
    virtual void __stdcall Fx2() = 0 ;
} ;

又是概念

当定义了一个抽象基类，也就定义了相应的内存结构，派生类实现了该抽象类才会被分配.

虚拟函数表包含一组指向虚拟函数实现的指针.

以上可以不管.下面的话才是重要的.

似乎是偶然的巧合,com接口的内存结构同c++编译器为抽象基类等所生成的内存结构是相同的。。。

由于这个巧合,IX即是接口，又是抽象基类。

由于这个巧合，我们就选择了c++,就像阿里的招聘广告 If not you,who?

六.关于类,接口,组件的一些简单理论概念

1.类非组件

组件这一称法太过专业,可以当作一个功能模块,按我的理解可以一个控件也是一个组件,如DataGrid是一个组件,DataGrid是由n多类组成一个功能强大的控件，所以类非组件. 话说话来,简单的组件也可以由一个类组成。概念而已,无需理会.不知道也不会怎么样…

2.接口与类的继承关系

一个类可以继承多个接口实现，也可以由一个接口一个类实现…

3.多重接口继承

即多个类继承相同接口(可以是多个接口)，不同实现…

4.命名冲突

怎么办?改名…要是遇到别人骚扰你，你改名，他也改名就没办法了...

好了,先写到这里.这篇其实与com组件基本无关的.

Microsoft.Expression.Interactivity 

这个dll文件有wpf和silverlight的不同版本,功能相同.

这个dll主要加了两个功能.

1.一个Behavior集合扩展行为

2.一个事件扩展行为

第一个大家都看到过了，第二个没人介绍过.

wpf有触发器的功能.通常用来改改控件属性，加加动画.

如DataTrigger和EventTrigger.

接着就是TriggerAction触发了

Setter就是其中之一.

可惜了TriggerAction抽象方法无法继承,导致无法扩展.微软为何不开放?我们可否用反射来调用抽象类的方法呢?

这样就出现了事件扩展行为,这个行为比设置控件的属性灵活多了.

不管怎么说，这个扩展包还是很有作用的.