xingzhe

转自: http://server.zdnet.com.cn/server/2008/1205/1266644.shtml

　　分布式应用程序和浏览器

　　研究一下当前的应用程序开发，你会发现一个绝对的倾向：人们开始偏爱基于浏览器的瘦客户应用程序。这当然不是因为瘦客户能够提供更好的用户界面，而是因为它能够避免花在桌面应用程序发布上的高成本。发布桌面应用程序成本很高，一半是因为应用程序安装和配置的问题，另一半是因为客户和服务器之间通信的问题。

　　传统的Windows富客户应用程序使用DCOM来与服务器进行通信和调用远程对象。配置好DCOM使其在一个大型的网络中正常工作将是一个极富挑战性的工作，同时也是许多IT工程师的噩梦。事实上，许多IT工程师宁愿忍受浏览器所带来的功能限制，也不愿在局域网上去运行一个DCOM。在我看来，结果就是一个发布容易，但开发难度大而且用户界面极其受限的应用程序。极端的说，就是你花了更多的资金和时间，却开发出从用户看来功能更弱的应用程序。不信?问问你的会计师对新的基于浏览器的会计软件有什么想法：绝大多数商用程序用户希望使用更加友好的Windows用户界面。

　　关于客户端与服务器的通信问题，一个完美的解决方法是使用HTTP协议来通信。这是因为任何运行Web浏览器的机器都在使用HTTP协议。同时，当前许多防火墙也配置为只允许HTTP连接。

　　许多商用程序还面临另一个问题，那就是与其他程序的互操作性。如果所有的应用程序都是使用COM或.NET语言写的，并且都运行在Windows平台上，那就天下太平了。然而，事实上大多数商业数据仍然在大型主机上以非关系文件(VSAM)的形式存放，并由COBOL语言编写的大型机程序访问。而且，目前还有很多商用程序继续在使用C++、Java、Visual Basic和其他各种各样的语言编写。现在，除了最简单的程序之外，所有的应用程序都需要与运行在其他异构平台上的应用程序集成并进行数据交换。这样的任务通常都是由特殊的方法，如文件传输和分析，消息队列，还有仅适用于某些情况的的API，如IBM的"高级程序到程序交流(APPC)"等来完成的。在以前，没有一个应用程序通信标准，是独立于平台、组建模型和编程语言的。只有通过Web Service，客户端和服务器才能够自由的用HTTP进行通信，不论两个程序的平台和编程语言是什么。

　　什么是Web Service

　　对这个问题，我们至少有两种答案。从表面上看，Web Service 就是一个应用程序，它向外界暴露出一个能够通过Web进行调用的API。这就是说，你能够用编程的方法通过Web来调用这个应用程序。我们把调用这个Web Service 的应用程序叫做客户。例如，你想创建一个Web Service ，它的作用是返回当前的天气情况。那么你可已建立一个ASP页面，它接受邮政编码作为查询字符串，然后返回一个由逗号隔开的字符串，包含了当前的气温和天气。要调用这个ASP页面，客户端需要发送下面的这个HTTP GET请求：

　　http://host.company.com/weather.asp?zipcode=20171

　　返回的数据就应该是这样：

　　这个ASP页面就应该可以算作是Web Service 了。因为它基于HTTP GET请求，暴露出了一个可以通过Web调用的API。当然，Web Service 还有更多的东西。

　　下面是对Web Service 更精确的解释： Web Services是建立可互操作的分布式应用程序的新平台。作为一个Windows程序员，你可能已经用COM或DCOM建立过基于组件的分布式应用程序。COM是一个非常好的组件技术，但是我们也很容易举出COM并不能满足要求的情况。

　　Web Service平台是一套标准，它定义了应用程序如何在Web上实现互操作性。你可以用任何你喜欢的语言，在任何你喜欢的平台上写Web Service ，只要我们可以通过Web Service标准对这些服务进行查询和访问。

　　新平台

　　Web Service平台需要一套协议来实现分布式应用程序的创建。任何平台都有它的数据表示方法和类型系统。要实现互操作性，Web Service平台必须提供一套标准的类型系统，用于沟通不同平台、编程语言和组件模型中的不同类型系统。在传统的分布式系统中，基于界面(interface)的平台提供了一些方法来描述界面、方法和参数(译注：如COM和COBAR中的IDL语言)。同样的，Web Service平台也必须提供一种标准来描述Web Service，让客户可以得到足够的信息来调用这个Web Service。最后，我们还必须有一种方法来对这个Web Service进行远程调用。这种方法实际是一种远程过程调用协议(RPC)。为了达到互操作性，这种RPC协议还必须与平台和编程语言无关。下面几个小节就简要介绍了组成Web Service平台的这三个技术。

　　XML和XSD

　　可扩展的标记语言(XML)是Web Service平台中表示数据的基本格式。除了易于建立和易于分析外，XML主要的优点在于它既是平台无关的，又是厂商无关的。无关性是比技术优越性更重要的：软件厂商是不会选择一个由竞争对手所发明的技术的。

　　XML解决了数据表示的问题，但它没有定义一套标准的数据类型，更没有说怎么去扩展这套数据类型。例如，整形数到底代表什么?16位，32位，还是64位?这些细节对实现互操作性都是很重要的。W3C制定的XML Schema(XSD)就是专门解决这个问题的一套标准。它定义了一套标准的数据类型，并给出了一种语言来扩展这套数据类型。Web Service平台就是用XSD来作为其数据类型系统的。当你用某种语言(如VB.NET或C#)来构造一个Web Service时，为了符合Web Service标准，所有你使用的数据类型都必须被转换为XSD类型。你用的工具可能已经自动帮你完成了这个转换，但你很可能会根据你的需要修改一下转换过程。在第二章中，我们将深入XSD，学习怎样转换自定义的数据类型(例如类)到XSD的类型。

　　SOAP

　　Web Service建好以后，你或者其他人就会去调用它。简单对象访问协议(SOAP)提供了标准的RPC方法来调用Web Service。实际上，SOAP在这里有点用词不当：它意味着下面的Web Service是以对象的方式表示的，但事实并不一定如此：你完全可以把你的Web Service写成一系列的C函数，并仍然使用SOAP进行调用。SOAP规范定义了SOAP消息的格式，以及怎样通过HTTP协议来使用SOAP。SOAP也是基于XML和XSD的，XML是SOAP的数据编码方式。第三章我们会讨论SOAP，并结识SOAP消息的各种元素。

　　WSDL

　　你会怎样向别人介绍你的Web Service有什么功能，以及每个函数调用时的参数呢?你可能会自己写一套文档，你甚至可能会口头上告诉需要使用你的Web Service的人。这些非正式的方法至少都有一个严重的问题：当程序员坐到电脑前，想要使用你的Web Service的时候，他们的工具(如Visual Studio)无法给他们提供任何帮助，因为这些工具根本就不了解你的Web

　　service。解决方法是：用机器能阅读的方式提供一个正式的描述文档。Web Service描述语言(WSDL)就是这样一个基于XML的语言，用于描述Web Service及其函数、参数和返回值。因为是基于XML的，所以WSDL既是机器可阅读的，又是人可阅读的，这将是一个很大的好处。一些最新的开发工具既能根据你的Web Service生成WSDL文档，又能导入WSDL文档，生成调用相应Web Service的代码。

/////////////////////////////////////////////////////////////////////////////
// Connection Point Helpers

ATLINLINE ATLAPI AtlAdvise(IUnknown* pUnkCP, IUnknown* pUnk, const IID& iid, LPDWORD pdw)
{
 if(pUnkCP == NULL)
  return E_INVALIDARG;
  
 CComPtr<IConnectionPointContainer> pCPC;
 CComPtr<IConnectionPoint> pCP;
 HRESULT hRes = pUnkCP->QueryInterface(__uuidof(IConnectionPointContainer), (void**)&pCPC);
 if (SUCCEEDED(hRes))
  hRes = pCPC->FindConnectionPoint(iid, &pCP);
 if (SUCCEEDED(hRes))
  hRes = pCP->Advise(pUnk, pdw);
 return hRes;
}

/////////////////////////////////////////////////////////////////////////////
ATLINLINE ATLAPI AtlUnadvise(IUnknown* pUnkCP, const IID& iid, DWORD dw)
{
 if(pUnkCP == NULL)
  return E_INVALIDARG;
  
 CComPtr<IConnectionPointContainer> pCPC;
 CComPtr<IConnectionPoint> pCP;
 HRESULT hRes = pUnkCP->QueryInterface(__uuidof(IConnectionPointContainer), (void**)&pCPC);
 if (SUCCEEDED(hRes))
  hRes = pCPC->FindConnectionPoint(iid, &pCP);
 if (SUCCEEDED(hRes))
  hRes = pCP->Unadvise(dw);
 return hRes;

// Client.cpp : Defines the entry point for the application.
//

#include "stdafx.h"
#include "Client.h"
#include <atlbase.h>
#include <atlcom.h>
#include <atlimpl.cpp>
#include "..\shm\SHM_i.h"
#include "..\shm\SHM_i.C"

//use VT_I4 with HRESULT
_ATL_FUNC_INFO AddCompParam = {CC_STDCALL, VT_I4,1,VT_I4};

// Global Variables:
HINSTANCE hInst;        // current instance
TCHAR szTitle[MAX_LOADSTRING];     // The title bar text
TCHAR szWindowClass[MAX_LOADSTRING];   // the main window class name

CComModule _Module;

class CUserATLCom
{
public:
 CUserATLCom()
 {
  CoInitialize(NULL);
 }
 ~CUserATLCom()
 {
  CoUninitialize();
 }
};

class CAddEvents:public IDispEventSimpleImpl<1, CAddEvents, &__uuidof(_IAddEvents)>
{
public:
 CAddEvents(){};

 long __stdcall AddCompleted(long hr)
 {
  LONG i = hr;
  return 1;
 }
 // IUnknown
 BEGIN_SINK_MAP(CAddEvents)
  SINK_ENTRY_INFO(1, __uuidof(_IAddEvents), 0x1, AddCompleted, &AddCompParam)
 END_SINK_MAP()

 STDMETHODIMP AddOk(BSTR bstrOK)
 {
  CComBSTR str(bstrOK);
  return S_OK;
 }
};
CUserATLCom _gUserATL;

// Forward declarations of functions included in this code module:
ATOM    MyRegisterClass(HINSTANCE hInstance);
BOOL    InitInstance(HINSTANCE, int);
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK About(HWND, UINT, WPARAM, LPARAM);

int APIENTRY _tWinMain(HINSTANCE hInstance,
        HINSTANCE hPrevInstance,
        LPTSTR    lpCmdLine,
        int       nCmdShow)
{
 UNREFERENCED_PARAMETER(hPrevInstance);
 UNREFERENCED_PARAMETER(lpCmdLine);

 _Module.Init(NULL, hInstance);

 //get Add com
 CComPtr<IAdd> ptrAdd;
 HRESULT hr;
 hr = CoCreateInstance(CLSID_Add, NULL, CLSCTX_SERVER, IID_IAdd, (void**)&ptrAdd);

 //get Add events
 CAddEvents* ptrAddEvents = new CAddEvents;
 ptrAddEvents->DispEventAdvise(ptrAdd);
 

 //fire connection point
 LONG lVal;
 ptrAdd->AddLongVal(1, 2, &lVal);
 ptrAdd->IsOK(BSTR("a"));

 //queryInter ISub interface
 CComPtr<ISub> ptrSub;
 hr = ptrAdd->QueryInterface(IID_ISub, (void**)&ptrSub);

 if(FAILED(hr))
 {
  ATLASSERT(FALSE);
 }

 //call the function of ISub
 ptrSub->SubFun(4,1,&lVal);

 return 1;

}

///

1.连接点 事件接口_IAddEvents包含连个方法AddCompleted 和IsOK
2.两个接口IAdd和ISub
IAdd 中的方法包括AddLongVal和IsOK在该方法中都fire一个事件。
Fire事件的过程：
Fire Event->Fire_EventHandle(CProxy_IAddEvents)->Invoke方法(客户端从IAddEvent派生)->调用客户端的方法。

// SHM.idl : IDL source for SHM
//

// This file will be processed by the MIDL tool to
// produce the type library (SHM.tlb) and marshalling code.

import "oaidl.idl";
import "ocidl.idl";

[
 object,
 uuid(A986F54E-A7C9-4B16-B542-450BAAAF84F5),
 dual,
 nonextensible,
 helpstring("IAdd Interface"),
 pointer_default(unique)
]
interface IAdd : IDispatch{
 [id(1), helpstring("method AddLongVal")] HRESULT AddLongVal([in] LONG lVal, [in] LONG rVal, [out,retval] LONG* retVal);
 [id(2), helpstring("method IsOK")] HRESULT IsOK([in] BSTR bstrOK);
};
[
 object,
 uuid(480C3EF7-812E-4818-9860-6729B56C62F2),
 dual,
 nonextensible,
 helpstring("ISub Interface"),
 pointer_default(unique)
]

interface ISub : IDispatch{
 [id(1), helpstring("method SubFun")] HRESULT SubFun([in] LONG lVal, [in] LONG rVal, [out,retval] LONG* retVal);
};
[
 uuid(7002FB8A-F615-4710-81AB-716F1A3ADD06),
 version(1.0),
 helpstring("SHM 1.0 Type Library")
]
library SHMLib
{
 importlib("stdole2.tlb");
 [
  uuid(5F66AE9F-1DFC-4621-B7A7-D0EFE04E0118),
  helpstring("_IAddEvents Interface")
 ]
 dispinterface _IAddEvents
 {
  properties:
  methods:
   [id(1), helpstring("method AddCompleted")] HRESULT AddCompleted([in] LONG val);
   [id(2), helpstring("method AddOK")] HRESULT IsOK(BSTR* szOK);
 };
 [
  uuid(AD7ABE60-1865-45E4-AE0B-ED16B1A9F5D1),
  helpstring("Add Class")
 ]
 coclass Add
 {
  [default] interface IAdd;
  interface ISub;
  [default, source] dispinterface _IAddEvents;
 };
};

///CAdd

// Add.h : Declaration of the CAdd

#pragma once
#include "resource.h"       // main symbols

#include "SHM_i.h"
#include "_IAddEvents_CP.h"

#if defined(_WIN32_WCE) && !defined(_CE_DCOM) && !defined(_CE_ALLOW_SINGLE_THREADED_OBJECTS_IN_MTA)
#error "Single-threaded COM objects are not properly supported on Windows CE platform, such as the Windows Mobile platforms that do not include full DCOM support. Define _CE_ALLOW_SINGLE_THREADED_OBJECTS_IN_MTA to force ATL to support creating single-thread COM object's and allow use of it's single-threaded COM object implementations. The threading model in your rgs file was set to 'Free' as that is the only threading model supported in non DCOM Windows CE platforms."
#endif

// CAdd

class ATL_NO_VTABLE CAdd :
 public CComObjectRootEx<CComSingleThreadModel>,
 public CComCoClass<CAdd, &CLSID_Add>,
 public IConnectionPointContainerImpl<CAdd>,
 public CProxy_IAddEvents<CAdd>,
 public IDispatchImpl<IAdd, &IID_IAdd, &LIBID_SHMLib, /*wMajor =*/ 1, /*wMinor =*/ 0>,
 public IDispatchImpl<_IAddEvents, &__uuidof(_IAddEvents), &LIBID_SHMLib, /* wMajor = */ 1, /* wMinor = */ 0>,
 public IDispatchImpl<ISub, &__uuidof(ISub), &LIBID_SHMLib, /* wMajor = */ 1, /* wMinor = */ 0>
{
public:
 CAdd()
 {
 }

 DECLARE_REGISTRY_RESOURCEID(IDR_ADD)

 BEGIN_COM_MAP(CAdd)
  COM_INTERFACE_ENTRY(IAdd)
  COM_INTERFACE_ENTRY2(IDispatch, _IAddEvents)
  COM_INTERFACE_ENTRY(IConnectionPointContainer)
  COM_INTERFACE_ENTRY(_IAddEvents)
  COM_INTERFACE_ENTRY(ISub)
 END_COM_MAP()

 BEGIN_CONNECTION_POINT_MAP(CAdd)
  CONNECTION_POINT_ENTRY(__uuidof(_IAddEvents))
 END_CONNECTION_POINT_MAP()

 DECLARE_PROTECT_FINAL_CONSTRUCT()

 HRESULT FinalConstruct()
 {
  return S_OK;
 }

 void FinalRelease()
 {
 }

public:

 STDMETHOD(AddLongVal)(LONG lVal, LONG rVal, LONG* retVal);

 // _IAddEvents Methods
public:
 STDMETHOD(AddCompleted)( LONG val)
 {
  // Add your function implementation here.
  return E_NOTIMPL;
 }

 STDMETHOD(IsOK)(BSTR bstrOK);

 // ISub Methods
public:
 STDMETHOD(SubFun)( LONG lVal,  LONG rVal,  LONG * retVal)
 {
  *retVal = lVal - rVal;
  return S_OK;
 }
};

OBJECT_ENTRY_AUTO(__uuidof(Add), CAdd)

///CProxy_IAddEvents<T>

#pragma once

template<class T>
class CProxy_IAddEvents :
 public IConnectionPointImpl<T, &__uuidof(_IAddEvents)>
{
public:
 HRESULT Fire_AddCompleted( LONG val)
 {
  HRESULT hr = S_OK;
  T * pThis = static_cast<T *>(this);
  int cConnections = m_vec.GetSize();

  for (int iConnection = 0; iConnection < cConnections; iConnection++)
  {
   pThis->Lock();
   CComPtr<IUnknown> punkConnection = m_vec.GetAt(iConnection);
   pThis->Unlock();

   IDispatch * pConnection = static_cast<IDispatch *>(punkConnection.p);

   if (pConnection)
   {
    CComVariant avarParams[1];
    avarParams[0] = val;
    avarParams[0].vt = VT_I4;
    CComVariant varResult;

    DISPPARAMS params = { avarParams, NULL, 1, 0 };
    hr = pConnection->Invoke(1, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &params, &varResult, NULL, NULL);
   }
  }
  return hr;
 }

 HRESULT Fire_IsOK( BSTR bstrOK)
 {
  HRESULT hr = S_OK;
  T * pThis = static_cast<T *>(this);
  int cConnections = m_vec.GetSize();

  for (int iConnection = 0; iConnection < cConnections; iConnection++)
  {
   pThis->Lock();
   CComPtr<IUnknown> punkConnection = m_vec.GetAt(iConnection);
   pThis->Unlock();

   IDispatch * pConnection = static_cast<IDispatch *>(punkConnection.p);

   if (pConnection)
   {
    CComVariant avarParams[1];
    avarParams[0] = bstrOK;
    avarParams[0].vt = VT_BSTR;
    CComVariant varResult;

    DISPPARAMS params = { avarParams, NULL, 1, 0 };
    hr = pConnection->Invoke(2, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &params, &varResult, NULL, NULL);
   }
  }
  return hr;
 }
};

///client

// Client.cpp : Defines the entry point for the application.
//

#include "stdafx.h"
#include "Client.h"
#include <atlbase.h>
#include <atlcom.h>
#include <atlimpl.cpp>
#include "..\shm\SHM_i.h"
#include "..\shm\SHM_i.C"

#define MAX_LOADSTRING 100

// Global Variables:
HINSTANCE hInst;        // current instance
TCHAR szTitle[MAX_LOADSTRING];     // The title bar text
TCHAR szWindowClass[MAX_LOADSTRING];   // the main window class name

CComModule _Module;

class CUserATLCom
{
public:
 CUserATLCom()
 {
  CoInitialize(NULL);
 }
 ~CUserATLCom()
 {
  CoUninitialize();
 }
};

class CAddEvents:public CComObjectRoot
 , public _IAddEvents
{
public:
 CAddEvents(){};

BEGIN_COM_MAP(CAddEvents)
 COM_INTERFACE_ENTRY(IDispatch)
 COM_INTERFACE_ENTRY(_IAddEvents)
END_COM_MAP()

// IUnknown

//IAddEvents
public:
 STDMETHODIMP GetTypeInfoCount(UINT *)
 {
  return E_NOTIMPL;
 }

 STDMETHODIMP GetTypeInfo(UINT iTInfo, LCID lcid, ITypeInfo ** ppTInfo)
 {
  return E_NOTIMPL;
 }

 STDMETHODIMP GetIDsOfNames(REFIID riid, LPOLESTR* rgszNames, UINT cNames, LCID lcid, DISPID *rgDisID)
 {
  return E_NOTIMPL;
 }

 STDMETHODIMP Invoke(DISPID dispIdMember,
      REFIID riid,
      LCID lcid,
      WORD wFlags,
      DISPPARAMS* pDisParams,
      VARIANT* pVarResult,
      EXCEPINFO* pExcepInfo,
      UINT* pnArgErr)
 {
  switch(dispIdMember)
  {
  case 0x1:
   { if (pDisParams->cArgs != 1)
    {
     return DISP_E_BADPARAMCOUNT;
    }
    if (pDisParams->cNamedArgs)
    {
     return DISP_E_NONAMEDARGS;
    }

    //Coerce the argument into a long
    HRESULT hr;
    VARIANTARG var;
    VariantInit(&var);
    hr = VariantChangeType(&var, &(pDisParams->rgvarg[0]), 0, VT_I4);

    if FAILED(hr)
    {
     return DISP_E_BADVARTYPE;
    }

    AddCompleted(var.lVal);

    break;

   }
  case 0x2:
   {
    if (pDisParams->cArgs != 1)
    {
     return DISP_E_BADPARAMCOUNT;
    }
    if (pDisParams->cNamedArgs)
    {
     return DISP_E_NONAMEDARGS;
    }

    //Coerce the argument into a long
    HRESULT hr;
    VARIANTARG var;
    VariantInit(&var);
    hr = VariantChangeType(&var, &(pDisParams->rgvarg[0]), 0, VT_BSTR);

    if FAILED(hr)
    {
     return DISP_E_BADVARTYPE;
    }

    AddOk(var.bstrVal);
   }

   break;
   default:
    {
     ATLASSERT(FALSE);
    }
      break;
  }
 }

 STDMETHODIMP AddCompleted( LONG val)
 {
  LONG i = val;
  return S_OK;
 }

 STDMETHODIMP AddOk(BSTR bstrOK)
 {
  CComBSTR str(bstrOK);
  return S_OK;
 }
};
CUserATLCom _gUserATL;

// Forward declarations of functions included in this code module:
ATOM    MyRegisterClass(HINSTANCE hInstance);
BOOL    InitInstance(HINSTANCE, int);
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK About(HWND, UINT, WPARAM, LPARAM);

int APIENTRY _tWinMain(HINSTANCE hInstance,
                     HINSTANCE hPrevInstance,
                     LPTSTR    lpCmdLine,
                     int       nCmdShow)
{
 UNREFERENCED_PARAMETER(hPrevInstance);
 UNREFERENCED_PARAMETER(lpCmdLine);

 _Module.Init(NULL, hInstance);

 //get Add com
 CComPtr<IAdd> ptrAdd;
 HRESULT hr;
 hr = CoCreateInstance(CLSID_Add, NULL, CLSCTX_SERVER, IID_IAdd, (void**)&ptrAdd);

 //get Add events
  CComObject<CAddEvents>* ptrAddEvents;
  CComObject<CAddEvents>::CreateInstance(&ptrAddEvents);
 
 //get pointer to the IUNKNOWN interface
 CComPtr<IUnknown>ptrEventsUnk = ptrAddEvents;

 DWORD dwCookie;
 hr = AtlAdvise(ptrAdd,ptrEventsUnk, DIID__IAddEvents, &dwCookie);
 if (FAILED(hr))
 {
  ATLASSERT(FALSE);
 }

 //fire connection point
 LONG lVal;
 ptrAdd->AddLongVal(1, 2, &lVal);
 ptrAdd->IsOK(BSTR("a"));

 //unadvise
 AtlUnadvise(ptrAdd, DIID__IAddEvents, dwCookie);

 //queryInter ISub interface
 CComPtr<ISub> ptrSub;
 hr = ptrAdd->QueryInterface(IID_ISub, (void**)&ptrSub);

 if(FAILED(hr))
 {
  ATLASSERT(FALSE);
 }

 //call the function of ISub
 ptrSub->SubFun(4,1,&lVal);

 return 1;

 
}

template< typename Devriving>
class CFileHandle
{
public:
 BEGIN_MSG_MAP(CFileHandle<Devriving>)
  COMMAND_ID_HANDLER(IDM_EXIT, OnFileExit)
  COMMAND_ID_HANDLER(IDM_NEW, OnFileNew)
 END_MSG_MAP()

 LRESULT OnFileExit(WORD, WORD, HWND, BOOL&);
 LRESULT OnFileNew(WORD, WORD, HWND, BOOL&);
};

template< typename Devriving>
LRESULT CFileHandle<Devriving>::OnFileExit(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
 static_cast<Devriving*>(this)->DestroyWindow();

 return 0;
}

template< typename Devriving>
LRESULT CFileHandle<Devriving>::OnFileNew(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
 static_cast<Devriving*>(this)->OnOK();

 return 0;
}

class CMyMainWnd:public CWindowImpl<CMyMainWnd>,
 public CFileHandle<CMyMainWnd>
{
public:
 BEGIN_MSG_MAP(CMyMainWnd)

 //message handler
 MESSAGE_HANDLER(WM_PAINT, OnPaint)

 //command handler
 //COMMAND_HANDLER(IDM_EXIT, 0, OnFileExit)

 //command id handler
 //COMMAND_ID_HANDLER(IDM_EXIT, OnFileExit)

 //chain to a base class
 CHAIN_MSG_MAP(CFileHandle<CMyMainWnd>)
 END_MSG_MAP()

public:
 
 LRESULT OnPaint(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled);
 
 //the message route to the base class member functions
 //not call these function
 LRESULT OnFileExit(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled);
 LRESULT OnFileNew(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled);

public:
 void OnOK(void);
};