在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，够省事的了。