在MFC中实现自己的类厂

CoCreateInstance中调用CoGetClassObject获得IClassFactory（IClassFactory2），IClassFactory2又调用自己的CreateInstance或CreateInstanceLic建立控件实例。这里面类厂（IClassFactory）起到了非常重要的作用，特别是在MFC中，所有的控件都派生自COleControl（COleControl又派生自CCmdTarget），而COleControl本身却没有实现任何的接口，包括IUnknown。所有的接口都在COleControl的包裹类中实现。因此这里的类厂还需要调用正确的函数来返回正确的IUnknown指针（这里一般会调用CCmdTarget的InternalQueryInterface而不是通常的QueryInterface，因为新建的COleControl实例指针本身并不是一个接口指针，不提供QueryInterface方法）。

在MFC中，IClassFactory由COleObjectFactory（或者COleObjectFactoryEx，其实是一样的）实现。其实COleObjectFactory本身也派生自CCmdTarget，也没有直接实现IClassFactory，而是由其包裹类XOleObjectFactory来实现的。

CoGetClassObject在注册表中找到正确的Dll后，就调用该Dll的DllGetClassObject来获得相应的类厂，在这里，MFC实现了DllGetClassObject，它搜索存在当前Dll模块中的COleObjectFactory列表，找到与所要求的类ID(CLSID)相对应的COleObjectFactory后，就调用COleObjectFactory(CCmdTarget)的InternalQueryInterface返回相应的IClassFactory2接口指针。

理论上讲应该可以完全撇开MFC的类厂机制，自己从头建一个类厂，自己实现DllGetClassObject。不过好象是没有什么必要的，我们完全可以从COleObjectFactory派生自己的类厂。只要在自己的这个类厂类（真别扭）中实现IClassFactory就可以了。

1.新建控件of
2.新建派生自COleObjectFactory的类CMyObjectFactory，并加入定义IClassFactory接口的宏，实现IClassFactory接口的代码和接口映射表，如下：

//MyObjectFactory.h
class CMyObjectFactory : public COleObjectFactoryEx 
{
public:
    void CreateErrorInfo();
    CMyObjectFactory(REFCLSID clsid, CRuntimeClass* pRuntimeClass,
        BOOL bMultiInstance, LPCTSTR lpszProgID) :
    COleObjectFactory(clsid, pRuntimeClass,    bMultiInstance, lpszProgID)
    {
    }
    virtual ~CMyObjectFactory();

    BEGIN_INTERFACE_PART(MyClassFactory, IClassFactory2)
        INIT_INTERFACE_PART(CMyObjectFactory, ClassFactory)
        STDMETHOD(CreateInstance)(LPUNKNOWN, REFIID, LPVOID*);
        STDMETHOD(LockServer)(BOOL);
        STDMETHOD(GetLicInfo)(LPLICINFO);
        STDMETHOD(RequestLicKey)(DWORD, BSTR*);
        STDMETHOD(CreateInstanceLic)(LPUNKNOWN, LPUNKNOWN, REFIID, BSTR,
            LPVOID*);
    END_INTERFACE_PART(MyClassFactory)

   DECLARE_INTERFACE_MAP()

};

//MyObjectFactory.cpp

BEGIN_INTERFACE_MAP(CMyObjectFactory, COleObjectFactoryEx)
    INTERFACE_PART(CMyObjectFactory, IID_IClassFactory, MyClassFactory)
    INTERFACE_PART(CMyObjectFactory, IID_IClassFactory2, MyClassFactory)
END_INTERFACE_MAP()

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CMyObjectFactory::~CMyObjectFactory()
{

}

STDMETHODIMP_(ULONG) CMyObjectFactory::XMyClassFactory::AddRef()
{
    METHOD_PROLOGUE_EX_(CMyObjectFactory, MyClassFactory)
    return pThis->InternalAddRef();
}

STDMETHODIMP_(ULONG) CMyObjectFactory::XMyClassFactory::Release()
{
    METHOD_PROLOGUE_EX_(CMyObjectFactory, MyClassFactory)
    return pThis->InternalRelease();
}

STDMETHODIMP CMyObjectFactory::XMyClassFactory::QueryInterface(
    REFIID iid, LPVOID* ppvObj)
{
    METHOD_PROLOGUE_EX_(CMyObjectFactory, MyClassFactory)
    return pThis->InternalQueryInterface(&iid, ppvObj);
}

STDMETHODIMP CMyObjectFactory::XMyClassFactory::CreateInstance(
    IUnknown* pUnkOuter, REFIID riid, LPVOID* ppvObject)
{
    return CreateInstanceLic(pUnkOuter, NULL, riid, NULL, ppvObject);
}

STDMETHODIMP CMyObjectFactory::XMyClassFactory::LockServer(BOOL fLock)
{
    METHOD_PROLOGUE_EX(CMyObjectFactory, MyClassFactory)
    ASSERT_VALID(pThis);

    SCODE sc = E_UNEXPECTED;
    TRY
    {
        if (fLock)
            AfxOleLockApp();
        else
            AfxOleUnlockApp();
        sc = S_OK;
    }
    END_TRY

    return sc;
}

STDMETHODIMP CMyObjectFactory::XMyClassFactory::GetLicInfo(
    LPLICINFO pLicInfo)
{
    METHOD_PROLOGUE_EX(CMyObjectFactory, MyClassFactory)
    ASSERT_VALID(pThis);

    BSTR bstr = NULL;
    pLicInfo->fLicVerified = pThis->IsLicenseValid();
    pLicInfo->fRuntimeKeyAvail = pThis->GetLicenseKey(0, &bstr);
    if (bstr != NULL)
        SysFreeString(bstr);

    return S_OK;
}

STDMETHODIMP CMyObjectFactory::XMyClassFactory::RequestLicKey(
    DWORD dwReserved, BSTR* pbstrKey)
{
    METHOD_PROLOGUE_EX(CMyObjectFactory, MyClassFactory)
    ASSERT_VALID(pThis);

    ASSERT(pbstrKey != NULL);

    *pbstrKey = NULL;

    if (pThis->IsLicenseValid())
    {
        if (pThis->GetLicenseKey(dwReserved, pbstrKey))
            return S_OK;
        else
            return E_FAIL;
    }
    else
        return CLASS_E_NOTLICENSED;
}

STDMETHODIMP CMyObjectFactory::XMyClassFactory::CreateInstanceLic(
    LPUNKNOWN pUnkOuter, LPUNKNOWN /* pUnkReserved */, REFIID riid,
    BSTR bstrKey, LPVOID* ppvObject)
{
    METHOD_PROLOGUE_EX(CMyObjectFactory, MyClassFactory)
    ASSERT_VALID(pThis);

    if (ppvObject == NULL)
        return E_POINTER;
    *ppvObject = NULL;

    if (((bstrKey != NULL) && !pThis->VerifyLicenseKey(bstrKey)) ||
        ((bstrKey == NULL) && !pThis->IsLicenseValid()))
        return CLASS_E_NOTLICENSED;

    // outer objects must ask for IUnknown only
    ASSERT(pUnkOuter == NULL || riid == IID_IUnknown);

    //这里加入消息框，以表示这是我的类厂
    MessageBox(NULL, "hello", NULL, MB_OK);
    // attempt to create the object
    CCmdTarget* pTarget = NULL;
    SCODE sc = E_OUTOFMEMORY;
    TRY
    {
        // attempt to create the object
        pTarget = pThis->OnCreateObject();
        if (pTarget != NULL)
        {
            // check for aggregation on object not supporting it
            sc = CLASS_E_NOAGGREGATION;
            if (pUnkOuter == NULL || pTarget->m_xInnerUnknown != 0)
            {
                // create aggregates used by the object
                pTarget->m_pOuterUnknown = pUnkOuter;
                sc = E_OUTOFMEMORY;
                if (pTarget->OnCreateAggregates())
                    sc = S_OK;
            }
        }
    }
    END_TRY

    // finish creation
    if (sc == S_OK)
    {
        DWORD dwRef = 1;
        if (pUnkOuter != NULL)
        {
            // return inner unknown instead of IUnknown
            *ppvObject = &pTarget->m_xInnerUnknown;
        }
        else
        {
            // query for requested interface
            sc = pTarget->InternalQueryInterface(&riid, ppvObject);
            if (sc == S_OK)
            {
                dwRef = pTarget->InternalRelease();
                ASSERT(dwRef != 0);
            }
        }
        if (dwRef != 1)
            TRACE1("Warning: object created with reference of %ld/n", dwRef);
    }

    // cleanup in case of errors
    if (sc != S_OK)
        delete pTarget;

    return sc;
}
这里的实现代码基本上都是从MFC的COleObjectFactory中拷过来的。只是在CreateInstanceLic方法中加了一个MessageBox。

3.现在要用我们的CMyObjectFactory来代替缺省的COleObjectFactory了。
a.我们先要定义几个宏，当然不用宏也可以，这里只是贪图方便罢了
#define BEGIN_MYOLEFACTORY(class_name) /
protected: /
    class class_name##Factory : public CMyObjectFactory /
    { /
    public: /
        class_name##Factory(REFCLSID clsid, CRuntimeClass* pRuntimeClass, /
            BOOL bMultiInstance, LPCTSTR lpszProgID) : /
                CMyObjectFactory(clsid, pRuntimeClass, bMultiInstance, /
                lpszProgID) {} /
        virtual BOOL UpdateRegistry(BOOL);

#define END_MYOLEFACTORY(class_name) /
    }; /
    friend class class_name##Factory; /
    static AFX_DATA class_name##Factory factory; /
public: /
    static AFX_DATA const GUID guid; /
    virtual HRESULT GetClassID(LPCLSID pclsid);

#define DECLARE_MYOLECREATE_EX(class_name) /
    BEGIN_MYOLEFACTORY(class_name) /
    END_MYOLEFACTORY(class_name)


在MFC中对应的是BEGIN_OLEFACTORY(class_name)和END_OLEFACTORY(class_name)，因为MFC中的这些宏已经定死了控件的类厂必须派生自COleObjectFactory（前面我们提到在模块上存放的列表就是COleObjectFactory指针列表，所以必须派生自COleObjectFactory是很显然的），而COleObjectFactory实现IClassFactory是在它的包裹类中，我们并不能直接继承COleObjectFactory就可以轻松的自己实现IClassFactory了，如果在由BEGIN_OLEFACTORYT和END_OLEFACTORY宏对中间定义我们自己的IClassFactory实现，那就变成包裹类的包裹类了，整个别扭的很啊，只好改它的宏了，幸好这几个宏并不复杂。

b.注释掉DECLARE_OLECREATE_EX(COfCtrl)，改成
    DECLARE_MYOLECREATE_EX(COfCtrl)

至于IMPLEMENT_OLECREATE_EX就不用改了，该怎样还怎样吧。

4.编译，测试吧。
将DECLARE_MYOLECREATE_EX改回DECLARE_OLECREATE_EX，再编译的话，就又用回缺省的COleObjectFactory，够省事的了。