博客园-首页原创.NET区

程序员零起步（二）——团队

Wed, 15 Feb 2012 02:10:00 +0800

谢谢大家的支持，费话了这么多，肯定是要继续费话的，嘿嘿，到上海奔波了几个月，生活未稳定，没心思过节呀，不过快乐还是要天天有的。

2011年3月，目前人生的一个很重要的转折（当然，不知道以后干吗，只能说目前）毅然没有选择考研，一个机遇，进了吴老师带的诚合工作室，开始了我的团队生活。介绍一下，诚合工作室是我们学校网络部的一个老师开创的，到我这里，已经培养了三批学生了，进去的时候，要我们从Java、.net、c++、美工里面选一个组进去学习，大概一个组有五个人左右的样子，已经有一批毕业了，到外面去工作了。当时跟我一起进去的有十一个人，一起的话，美工组除了组长是男生，被五个女生包围外，其余组几乎是男生。有几个女生之前也是选.net的，不过学了一段时间，老师还是建议她们转美工了，c++是全部是男生，呵呵，对于我对语言方面了解，c++是男女比例最失调的，特别是做游戏，几乎没有女生会选择吧。虽然我现在比较喜欢编程，不过确实对算法方面，不是那么的感兴趣，但是，要是让我去配色、Ps的话，我还是编程吧，那个，实在是觉得要天赋，我是觉得自己是没有一点艺术素养的人。

那个时候的我也已经大三了，马上要面临毕业了，还是选择了上手最快的.net，也出于之前看过一点c#的，自认为有点基础，真的接触，发现自己真的是什么都不知道，HTML是什么都还不怎么清楚，更谈不上JavaScript、JQuery什么的了。对于我来说也是件好事，一听到新的东西就感兴趣，那时候也不愿意去做别的什么了，去上课，睡觉的也是一大堆，每天去抢最后一排，由于经常不急不忙，以至于最后一排也抢不到，又不好意思在第一排打瞌睡，所幸就天天窝在工作室学习了。那里学习环境确实很不错，大家年龄也差不多，也不是为了赚钱，也不用比成绩，完全兴趣爱好，相处的都非常好，加上吴老师跟陈老师确实也对我们特别好，网络信息部的老师，手上有好多学校的项目，哎，不得不说一句，学校做的东西确实有点垃圾，也就都拿给我们练手了，也充当经费，差不多每两个星期会组织我们活动，学得确实比较快，如果你在的学校有这样的机会，一点不要放弃，好好在里面学，这些都没有人管的，没有人压迫你做什么，只提供一个环境，差不多也算是社会实践吧，起码我觉得，如果没有在里面的一年多，我出来是觉得没有人理的，先不要谈工作，应届毕业生，人家面试都不给机会的（来上海几个月了，面试了好多次，也从来没有觉得自己在学校做过一点项目就了不起，因为这充其量也只能当作一个入门，商业化的东西跟我们在学校学的确实相差很大）。

无论在哪里，我都觉得虚心很重要，进诚合工作室之前，里面已经有一批人是比我早进去一两个月的，还有一些是之前自己有学过编程的，那时候觉得他们好厉害（确实比我厉害好多）。每个组有一个组长，算是带我们吧，跟组长交流后，他说他差不多也是自学，说是培训了一个月，真正做程序的人，哪里会跟你讲什么，就是带他们入门吧，组长也比较好，把那些个老师说的话跟我说了一点，告诉我，没事多到网上看看，带着好奇心，现在工作室也有几个项目，老师就是给我们几个需求说明书，详细的都没有，就告诉我们要实现些个什么功能，怎么实现不管你们，反正要做出他要的效果。没办法，就做的，不会就百度，有空的时候，工作室有一堆书就拿来看，程序员加美工，两三个月下来，也做出了一堆的东西来，说是说是系统，B/S模式的，用.net开发的也有、Java开发的也有（c++组的一直在搞研究，至今不懂他们在研究什么深奥的东西，很困惑），没有什么测试人员，随便来几个无聊的人攻击一下，就差不多瘫了。系统烂是有点烂，不管怎么说，从做设计到编码，再到发布，加最痛苦的无数次的修改，总算还是小有点成就感，现在还很怀念那时候大家一起做开发，起码现在在公司是很难有这种感觉的，所以也一直想毕业后，找到一个好一点的公司，进一个好一点的团队，稳定一点，好好做开发。

吴老师现在差不多三十岁，一直说自己现在再不创业，就没有机会了，半年前就把工作室注册成了公司，暑假的时候就把我们全部招回去，去外面接项目。回去了的也就六七个，六月底七月初学校安排我们专业到南昌中兴软件园培训了半个来月的Java，五个人一组也就在那边做了一个小项目，我们.net组的，大家关系都很好，项目也一直是最多的，去了一半，中兴培训一完，回家一个星期我也就去学校了。其余的当然没有想过把自己以后的工作也押到刚起步的公司上，或是偷偷懒，暑假好好玩去了。我那时候是去了的，无论之后怎么选择，只要有锻炼、学习的机会，都是不会放弃的，确实很值得这样做，年轻就是要多奋斗吧。去的人少，又是去外面接项目，不用说，那个月很辛苦。老师也比较忙，出于对我们几个的信任，有时候去跟客户谈项目，就是我开着老师的车跟我们组组长两个人去跟客户谈需求的，虽说考了驾照，旁边没坐个会开车的，又在市区里面开，真是每天擦汗啊。跟外面的人谈项目也不像给学校做那么简单，难受是不免有的，他们也不懂程序这方面，什么乱七八糟的要求都有，而且觉得这个东西很简单，也不肯给多少钱，还经常要加班加点的。有一次碰到一个老表，直接要我们一天给他设计一个新闻发布网站，谈了四五次，终于通过了，结果通过的那天，就说他们领导明天要检查，不可能是不能点的呀，要是能看到实际内容的。哎，真是没办法，直接把我们两留到那里（那时候是下乡，听着真别扭），硬是通宵一个晚上把他做成他口里的，所谓能“动”的网站。嗯，大家应该也都想到了，我们之前做项目，怎么了积累了一些架构、模板什么的，新闻类的也是有的，也只有远程连接，拿过来，项目名称都来不及改，找点数据导到数据库里，先用着了。。。

暑假，很充实的过去了，经常是不知道什么时候是白天，什么时候是黑夜的，知道自己技术不咋的，做人方面，见识方面，到是有点小长进。

大四了，考研的考研，也陆续有人出去找工作了，学校也开了招聘会，哎，可是招计算机的几乎只有去做Word、Excel的（我在的学校，只有是工科方面的），看到那些个同级的签了就业协议，异或是看着考研的人那么努力奔图书馆，自己也按捺不住了，也急得慌，虽然吴老师说，公司给我们几个股份（那时候坚持下来的，08级的也就几个组长跟副组长了），项目拿钱给我们分红，但是，老师毕竟是老师，永远做不到以老板或是共同创业的伙伴对待，再次，江西软件方面的发展，对于还在学习的我们，足足不够，大家也就降降四处漂了。

一直没提，对于偏向于理科方面的我，英语不是很好，刚进大学就选学日语去了，刚开始也只是学校提供机会，可以不上英语课，不考英语，去上日语课，后面也竟喜欢上了，那时没人指引，也不知道考证的重要性，也没去考。但是，出于想做程序的另一方面，也不想丢掉自己的日语，找工作的时候，程序员无非是到北上广的，上海这边对日外包的比较多，一个机遇，就跑过来的。

又写了一堆，还没开始讲自己的求职经历，明天继续吧。。。

本文链接

通用异步 Windows TCP Socket 客户端组件的设计与实现

Wed, 15 Feb 2012 01:26:00 +0800

编写 Windows TCP Socket 客户端其实并不困难，Windows 提供了6种 I/O 通信模型供大家选择。但本座看过很多客户端程序都把 Socket 通信和业务逻辑混在一起，剪不断理还乱。每个程序都 Copy / Parse 类似的代码再进行修改，实在有点情何以堪。因此本座利用一些闲暇时光写了一个基于 IOCP 的通用异步 Windows TCP Socket 服务端组件和一个通用异步 Windows TCP Socket 客户端组件供各位看官参详参详，希望能激发下大家的灵感。本篇文章讲述客户端组件，以后有时间再和大家探讨下服务端组件的实现。闲话少说，我们现在步入正题。

最重要的第一个问题：如何才能达到通用？

答：很简单。

1、限制组件的职能，说白了，通信组件的唯一职责就是接受和发送字节流，绝对不能参与上层协议解析等工作。不在其位不谋其政就是这个意思。

2、与上层使用者解耦、互不依赖，组件与使用者通过接口方法进行交互，组件实现 ISocketClient 接口为上层提供操作方法；使用者通过 IClientSocketListener 接口把自己注册为组件的 Listener，接收组件通知。因此，任何使用者只要实现了 IClientSocketListener 接口都可以使用组件；另一方面，你甚至可以自己重新写一个实现方式完全不同的组件实现给使用者调用，只要该组件遵从 ISocketClient 接口。这也是 DIP 设计原则的体现（猛击这里你会有惊喜^_^）。

最重要的第二个问题：可用性如何，也就是说使用起来是否是否方便？

答：这个问题问得很好，可用性对所有通用组件都是至关重要的，如果太难用还不如自己重头写一个来得方便。因此，ISocketClient 和 IClientSocketListener 接口设计得尽量简单易用（通俗来说就是“傻瓜化”），这两个接口的主要方法均不超过 5 个。

最重要的第三个问题：组件的性能如何？

作为底层的通用组件，性能问题是必须考虑的，绝对不能成为系统的瓶颈。而另一方面，从实际出发，毕竟只是一个客户端组件，它的并发性要求远没有服务端那么高。因此，组件在设计上充分考虑了性能、现实使用情景、可用性和实现复杂性等因素，确保满足性能要求的同时又不会写得太复杂。做出以下两点设计决策：

1. 在单独线程中实现 Socket 通信交互。这样可以避免与主线程或其他线程相互干扰。
2. I/O 模型选择 WSAEventSelect。细说一下选择这种 I/O 模型的原因：（各种 I/O 模型的性能比较可以参考：《Windows 网络编程（中文第二版）》第 154 页）
  - 阻塞模型：（不解析，你懂的^_^）
  - 非阻塞模型：（性能太低）
  - WSAAsyncSelect：（两个原因：a、性能太低；b、对于纯 Console 程序还要背负 HWND 实在是伤不起呀！）
  - 重叠 I/O：（有点复杂了）
  - 完成端口：（何必呢？）

唉，理论的东西就先别吹那么多了，直接上代码吧，求你了！！

OK！先看看 ISocketClient 和 IClientSocketListener 的接口定义:

// 组件操作类型
enum EnSocketOperation
{
    SO_UNKNOWN    = 0,
    SO_ACCEPT    = 1,
    SO_CONNECT    = 2,
    SO_SEND        = 3,
    SO_RECEIVE    = 4,
};

// 组件监听器基接口
class ISocketListener
{
public:
    enum EnHandleResult
    {
        HR_OK        = 0,
        HR_IGNORE    = 1,
        HR_ERROR    = 2,
    };

public:
 // 已发出数据通知
 virtual EnHandleResult OnSend(DWORD dwConnectionID, const BYTE* pData, int iLength) = 0;
 // 已接收数据通知
 virtual EnHandleResult OnReceive(DWORD dwConnectionID, const BYTE* pData, int iLength) = 0;
 // 关闭 socket 通知
 virtual EnHandleResult OnClose(DWORD dwConnectionID) = 0;
 // socket 错误数据通知
 virtual EnHandleResult OnError(DWORD dwConnectionID, EnSocketOperation enOperation, int iErrorCode) = 0;

public:
    virtual ~ISocketListener() {}
};

// 服务端组件监听器接口（暂时无视之）
class IServerSocketListener : public ISocketListener
{
public:
    // 接收连接通知
    virtual EnHandleResult OnAccept(DWORD dwConnectionID)    = 0;
    // 服务关闭通知
    virtual EnHandleResult OnServerShutdown()                = 0;
};

// 客户端组件监听器接口
class IClientSocketListener : public ISocketListener
{
public:
    // 连接完成通知
 virtual EnHandleResult OnConnect(DWORD dwConnectionID) = 0;
};

// 服务端组件接口（暂时无视之）
class ISocketServer
{
public:
    enum En_ISS_Error
    {
        ISS_OK                        = 0,
        ISS_SOCKET_CREATE            = 1,
        ISS_SOCKET_BIND                = 2,
        ISS_SOCKET_LISTEN            = 3,
        ISS_CP_CREATE                = 4,
        ISS_WORKER_THREAD_CREATE    = 5,
        ISS_SOCKE_ATTACH_TO_CP        = 6,
        ISS_ACCEPT_THREAD_CREATE    = 7,
    };

public:
    virtual BOOL Start    (LPCTSTR pszBindAddress, USHORT usPort, long lThreadCount)            = 0;
    virtual BOOL Stop    ()                                                                    = 0;
    virtual BOOL Send    (DWORD dwConnID, const BYTE* pBuffer, int iLen)                        = 0;
    virtual BOOL HasStarted                ()                                                    = 0;
    virtual En_ISS_Error GetLastError    ()                                                    = 0;
    virtual LPCTSTR        GetLastErrorDesc()                                                    = 0;
    virtual BOOL GetConnectionAddress(DWORD dwConnID, CString& strAddress, USHORT& usPort)    = 0;


public:
    virtual ~ISocketServer() {}
};

// 服务端组件接口智能指针
typedef auto_ptr<ISocketServer>    ISocketServerPtr;

// 客户端组件接口
class ISocketClient
{
public:
    // 操作结果码
    enum En_ISC_Error
    {
        ISC_OK                        = 0,
        ISC_CLIENT_HAD_STARTED        = 1,
        ISC_CLIENT_NOT_STARTED        = 2,
        ISC_SOCKET_CREATE_FAIL        = 3,
        ISC_CONNECT_SERVER_FAIL        = 4,
        ISC_WORKER_CREATE_FAIL        = 5,
        ISC_NETWORK_ERROR            = 6,
        ISC_PROTOCOL_ERROR            = 7,
    };

public:
 // 启动通信
 virtual BOOL Start (LPCTSTR pszRemoteAddress, USHORT usPort) = 0;
 // 关闭通信
 virtual BOOL Stop () = 0;
 // 发送数据
 virtual BOOL Send (DWORD dwConnID, const BYTE* pBuffer, int iLen) = 0;
 // 是否已启动
 virtual BOOL HasStarted () = 0;
 // 获取错误码
 virtual En_ISC_Error GetLastError () = 0;
 // 获取错误描述
 virtual LPCTSTR GetLastErrorDesc() = 0;

public:
    virtual ~ISocketClient() {}
};

// 客户端组件接口智能指针
typedef auto_ptr<ISocketClient>    ISocketClientPtr;

ISocketClient 接口主要有以下三个方法：

Start()：启动通信
Send()：发送数据
Stop()：停止通信

IClientSocketListener 接口有以下五个通知方法：

OnConnect()
OnSend()
OnReceive()
OnClose()
OnError()

够简单了吧^_^，使用者只需通过三个方法操作组件，然后处理五个组件通知。下面我们再看看组件的具体实现，先看组件类定义：

/* 组件实现类 */
class CSocketClient : public ISocketClient
{
// ISocketClient 接口方法
public:
 virtual BOOL Start (LPCTSTR pszRemoteAddress, USHORT usPortt);
 virtual BOOL Stop ();
 virtual BOOL Send (DWORD dwConnID, const BYTE* pBuffer, int iLen);
 virtual BOOL HasStarted () {return m_bStarted;}
 virtual En_ISC_Error GetLastError () {return sm_enLastError;}
 virtual LPCTSTR GetLastErrorDesc();

private:
    BOOL CreateClientSocket();
    BOOL ConnectToServer(LPCTSTR pszRemoteAddress, USHORT usPort);
    BOOL CreateWorkerThread();
    // 网络事件处理方法
    BOOL ProcessNetworkEvent();
    void WaitForWorkerThreadEnd();
    BOOL ReadData();
    BOOL SendData();

    void SetLastError(En_ISC_Error code, LPCTSTR func, int ec);

// 通信线程函数
static 
#ifndef _WIN32_WCE
    UINT
#else
    DWORD
#endif
     WINAPI WorkerThreadProc(LPVOID pv);

private:
    static const int RECEIVE_BUFFER_SIZE    = 8 * 1024;
    static const int WORKER_THREAD_END_TIME    = 3 * 1000;

    static const long    DEFALUT_KEEPALIVE_TIMES        = 3;
    static const long    DEFALUT_KEEPALIVE_INTERVAL    = 10 * 1000;


// 构造函数
public:
 CSocketClient(IClientSocketListener* pListener)
 : m_pListener(pListener) // 设置监听器对象
 , m_soClient(INVALID_SOCKET)
 , m_evSocket(NULL)
 , m_dwConnID(0)
 , m_hWorker(NULL)
 , m_dwWorkerID(0)
 , m_bStarted(FALSE)
#ifdef _WIN32_WCE
 , sm_enLastError(ISC_OK)
#endif
 {
 ASSERT(m_pListener);
 }

    virtual ~CSocketClient()    {if(HasStarted()) Stop();}

private:
    // 这是神马 ？？？
 CInitSocket m_wsSocket;
    
    SOCKET            m_soClient;
    HANDLE            m_evSocket;
    DWORD            m_dwConnID;

    CCriSec            m_scStop;
    CEvt            m_evStop;
    HANDLE            m_hWorker;

#ifndef _WIN32_WCE
    UINT
#else
    DWORD
#endif
                    m_dwWorkerID;

    CBufferPtr        m_sndBuffer;
    CCriSec            m_scBuffer;
    CEvt            m_evBuffer;

    volatile BOOL    m_bStarted;

private:
    // 监听器对象指针
    IClientSocketListener* m_pListener;

#ifndef _WIN32_WCE
    __declspec(thread) static En_ISC_Error    sm_enLastError;
#else
    volatile En_ISC_Error                    sm_enLastError;
#endif
};

从上面的定义可以看出，组件实现类本身并没有提供额外的公共方法，它完全是可以被替换的。组件在构造函数中接收监听器对象，并且保存为其成员属性，因此可以在需要的时候向监听器发送事件通知。

另外，不知各位看官是否注意到一个奇怪的成员属性：“CInitSocket m_wsSocket; ”，这个属性在其它地方从来都不会用到，那么它是干嘛的呢？在回答这个问题之前，首先想问问大家：Windows Socket 操作的整个操作过程中，第一个以及最后一个被调用的方法是什么？是 socket()、connect()、bind()、还是 closesocket() 吗？都错！答案是 —— ::WSAStartup() 和 ::WSACleanup()。每个程序都要调用一下这两个方法确实是很烦的，又不雅观。其实，m_wsSocket 的唯一目的就是为了避免手工调用者两个方法，看看它的定义就明白了：

class CInitSocket
{
public:
    CInitSocket(LPWSADATA lpWSAData = NULL, BYTE minorVersion = 2, BYTE majorVersion = 2)
    {
        LPWSADATA lpTemp = lpWSAData;
        if(!lpTemp)
            lpTemp    = (LPWSADATA)_alloca(sizeof(WSADATA));

        m_iResult    = ::WSAStartup(MAKEWORD(minorVersion, majorVersion), lpTemp);
    }

    ~CInitSocket()
    {
        if(IsValid())
            ::WSACleanup();
    }

    int        GetResult()    {return m_iResult;}
    BOOL    IsValid()    {return m_iResult == 0;}

private:
    int        m_iResult;
};

现在我们看看组件类实现文件中几个重要方法的定义：

// 组件事件触发宏定义
#define FireConnect(id)                    m_pListener->OnConnect(id)
#define FireSend(id, data, len)            (m_bStarted ? m_pListener->OnSend(id, data, len)    : ISocketListener::HR_IGNORE)
#define FireReceive(id, data, len)        (m_bStarted ? m_pListener->OnReceive(id, data, len)    : ISocketListener::HR_IGNORE)
#define FireClose(id)                    (m_bStarted ? m_pListener->OnClose(id)                : ISocketListener::HR_IGNORE)
#define FireError(id, op, code)            (m_bStarted ? m_pListener->OnError(id, op, code)    : ISocketListener::HR_IGNORE)

// 启动组件
BOOL CSocketClient::Start(LPCTSTR pszRemoteAddress, USHORT usPort)
{
    BOOL isOK = FALSE;

    if(HasStarted())
    {
        SetLastError(ISC_CLIENT_HAD_STARTED, _T(__FUNCTION__), 0);
        return isOK;
    }

    // 创建 socket
    if(CreateClientSocket())
    {
        // 连接服务器（内部会调用 FireConnect() ）
        if(ConnectToServer(pszRemoteAddress, usPort))
        {
            // 创建工作线程
            if(CreateWorkerThread())
                isOK = TRUE;
            else
                SetLastError(ISC_WORKER_CREATE_FAIL, _T(__FUNCTION__), 0);
        }
        else
            SetLastError(ISC_CONNECT_SERVER_FAIL, _T(__FUNCTION__), ::WSAGetLastError());
    }
    else
        SetLastError(ISC_SOCKET_CREATE_FAIL, _T(__FUNCTION__), ::WSAGetLastError());

    isOK ? m_bStarted = TRUE : Stop();

    return isOK;
}

// 关闭组件
BOOL CSocketClient::Stop()
{
    {
        CCriSecLock locallock(m_scStop);

        m_bStarted = FALSE;

        if(m_hWorker != NULL)
        {
            // 停止工作线程
            if(::GetCurrentThreadId() != m_dwWorkerID)
                WaitForWorkerThreadEnd();

            ::CloseHandle(m_hWorker);
            m_hWorker        = NULL;
            m_dwWorkerID    = 0;
        }

        if(m_evSocket != NULL)
        {
            // 关闭 WSAEvent
            ::WSACloseEvent(m_evSocket);
            m_evSocket    = NULL;
        }

        if(m_soClient != INVALID_SOCKET)
        {
            // 关闭socket
            shutdown(m_soClient, SD_SEND);
            closesocket(m_soClient);
            m_soClient    = INVALID_SOCKET;
        }

        m_dwConnID = 0;
    }

 // 释放其它资源
    m_sndBuffer.Free();
    m_evBuffer.Reset();
    m_evStop.Reset();

    return TRUE;
}

// 发送数据
BOOL CSocketClient::Send(DWORD dwConnID, const BYTE* pBuffer, int iLen)
{
    ASSERT(iLen > 0);

    if(!HasStarted())
    {
        SetLastError(ISC_CLIENT_NOT_STARTED, _T(__FUNCTION__), 0);
        return FALSE;
    }

    CCriSecLock locallock(m_scBuffer);
    
    // 把数据存入缓冲器
    m_sndBuffer.Cat(pBuffer, iLen);
　　// 唤醒工作现场，发送数据
    m_evBuffer.Set();

    return TRUE;
}

// 工作线程函数
#ifndef _WIN32_WCE
    UINT
#else
    DWORD
#endif
    WINAPI CSocketClient::WorkerThreadProc(LPVOID pv)
{
    CSocketClient* pClient = (CSocketClient*)pv;

    TRACE0("---------------> 启动工作线程 <---------------\n");

    HANDLE hEvents[] = {pClient->m_evSocket, pClient->m_evBuffer, pClient->m_evStop};

    while(pClient->HasStarted())
    {
        // 等待 socket 事件、发送数据事件和停止通信事件
        DWORD retval = ::MsgWaitForMultipleObjectsEx(3, hEvents, WSA_INFINITE, QS_ALLINPUT, MWMO_INPUTAVAILABLE);

        if(retval == WSA_WAIT_EVENT_0)
        {
            // 处理网络消息
            if(!pClient->ProcessNetworkEvent())
            {
                if(pClient->HasStarted())
                    pClient->Stop();

                break;
            }
        }
        else if(retval == WSA_WAIT_EVENT_0 + 1)
        {
            // 发送数据（内部调用 FireSend() ）
            if(!pClient->SendData())
            {
                if(pClient->HasStarted())
                    pClient->Stop();

                break;
            }
        }
        else if(retval == WSA_WAIT_EVENT_0 + 2)
            break;
        else if(retval == WSA_WAIT_EVENT_0 + 3)
            // 消息循环
            ::PeekMessageLoop();
        else
            ASSERT(FALSE);
    }

    TRACE0("---------------> 退出工作线程 <---------------\n");

    return 0;
}

// 处理网络消息
BOOL CSocketClient::ProcessNetworkEvent()
{
    ::WSAResetEvent(m_evSocket);

    WSANETWORKEVENTS events;
    
    int rc = ::WSAEnumNetworkEvents(m_soClient, m_evSocket, &events);
    
    if(rc == SOCKET_ERROR)
    {
        int code = ::WSAGetLastError();
        SetLastError(ISC_NETWORK_ERROR, _T(__FUNCTION__), code);
        FireError(m_dwConnID, SO_UNKNOWN, code);

        return FALSE;
    }

    /* 可读取 */
    if(events.lNetworkEvents & FD_READ)
    {
        int iCode = events.iErrorCode[FD_READ_BIT];

        if(iCode == 0)
            // 读取数据（内部调用 FireReceive() ）
            return ReadData();
        else
        {
            SetLastError(ISC_NETWORK_ERROR, _T(__FUNCTION__), iCode);
            FireError(m_dwConnID, SO_RECEIVE, iCode);
            return FALSE;
        }
    }

    /* 可发送 */
    if(events.lNetworkEvents & FD_WRITE)
    {
        int iCode = events.iErrorCode[FD_WRITE_BIT];

        if(iCode == 0)
            // 发送数据（内部调用 FireSend() ）
            return SendData();
        else
        {
            SetLastError(ISC_NETWORK_ERROR, _T(__FUNCTION__), iCode);
            FireError(m_dwConnID, SO_SEND, iCode);
            return FALSE;
        }
    }

    /* socket 已关闭 */
    if(events.lNetworkEvents & FD_CLOSE)
    {
        int iCode = events.iErrorCode[FD_CLOSE_BIT];

        if(iCode == 0)
            FireClose(m_dwConnID);
        else
        {
            SetLastError(ISC_NETWORK_ERROR, _T(__FUNCTION__), iCode);
            FireError(m_dwConnID, SO_UNKNOWN, iCode);
        }

        return FALSE;
    }

    return TRUE;
}

从上面的代码可以看出：通信过程中，组件的使用者不需要对通信过程进行任何干预，整个底层通信过程对使用者来说是透明的，使用只需集中精力处理好几个组件通知。下面来看看组件的一个使用示例：

/* 组件使用者：实现 IClientSocketListener */
class CMainClient : public IClientSocketListener
{
// 这些方法会操作组件
public:
    bool Login(LPCTSTR pszAddress, USHORT usPort, const T_101_Data* pData);
    bool Logout(const T_201_Data* pData);
        BOOL SendData(EnCommandType enCmdType, const TCommandData* pCmdData, WORD wCmdDataLen);
    long    GetLastError();
    LPCTSTR    GetLastErrorDesc();

// 实现 IClientSocketListener
public:
 virtual EnHandleResult OnConnect(DWORD dwConnectionID);
 virtual EnHandleResult OnSend(DWORD dwConnectionID, const BYTE* pData, int iLength);
 virtual EnHandleResult OnReceive(DWORD dwConnectionID, const BYTE* pData, int iLen);
 virtual EnHandleResult OnClose(DWORD dwConnectionID);
 virtual EnHandleResult OnError(DWORD dwConnectionID, EnSocketOperation enOperation, int iErrorCode);

private:
    BOOL ParseReceiveBuffer();
    
    // 其它方法 。。。

// 构造函数
public:
 CMainClient()
 // 创建组件，并把自己设置为组件的监听器
 : m_pscClient(new CSocketClient(this))
 , m_dwConnID(0)
 {
 }

    virtual ~CMainClient()    {}

private:
    // 组件属性
    ISocketClientPtr m_pscClient;
    DWORD               m_dwConnID;
    
    // 其它属性 。。。
};

BOOL CMainClient::Login(LPCTSTR pszAddress, USHORT usPort, const T_101_Data* pData)
{
    // 启动通信
    return    m_pscClient->Start(pszAddress, usPort) &&
            SendData(CS_C_LOGIN_REQ, pData, sizeof(T_101_Data));
}

BOOL CMainClient::Logout(const T_201_Data* pData)
{
    if(pData)
    {
        SendData(CS_C_SET_STATUS, pData, sizeof(T_201_Data));
        ::WaitWithMessageLoop(LOGOUT_WAIT_TIME);
    }

    // 停止通信
    return m_pscClient->Stop();
}

BOOL CMainClient::SendData(EnCommandType enCmdType, const TCommandData* pCmdData, WORD wCmdDataLen)
{
    const WORD wBufferLen    = CMD_ADDITIVE_SIZE + wCmdDataLen;
    CPrivateHeapByteBuffer buffer(m_hpPrivate, wBufferLen);
    BYTE* pBuffer    = buffer;

    memcpy(pBuffer, &wBufferLen, CMD_LEN_SIZE);
    pBuffer += CMD_LEN_SIZE;
    memcpy(pBuffer, &enCmdType, CMD_TYPE_SIZE);
    pBuffer += CMD_TYPE_SIZE;
    memcpy(pBuffer, pCmdData, wCmdDataLen);
    pBuffer += wCmdDataLen;
    memcpy(pBuffer, &CMD_FLAG, CMD_FLAG_SIZE);

    // 发送数据
    return m_pscClient->Send(m_dwConnID, buffer, wBufferLen);
}

long CMainClient::GetLastError()
{
    // 获取通信错误码
    return m_pscClient->GetLastError();
}

LPCTSTR CMainClient::GetLastErrorDesc()
{
    // 获取通信错误描述
    return m_pscClient->GetLastErrorDesc();
}

/* 处理连接成功事件 */
ISocketListener::EnHandleResult CMainClient::OnConnect(DWORD dwConnectionID)
{
    TRACE1("<CNNID: %d> 已连接\n", dwConnectionID);
    m_dwConnID = dwConnectionID;
    return HR_OK;
}

/* 处理数据已发出事件 */
ISocketListener::EnHandleResult CMainClient::OnSend(DWORD dwConnectionID, const BYTE* pData, int iLength)
{
    TRACE2("<CNNID: %d> 发出数据包 (%d bytes)\n", dwConnectionID, iLength);
    return HR_OK;
}

/* 处理接收到数据事件*/
ISocketListener::EnHandleResult CMainClient::OnReceive(DWORD dwConnectionID, const BYTE* pData, int iLen)
{
    TRACE2("<CNNID: %d> 接收数据包 (%d bytes)\n", dwConnectionID, iLen);

    ASSERT(pData != NULL && iLen > 0);

    // 保存数据
    m_rcBuffer.Cat(pData, iLen);

    // 解析数据
    return ParseReceiveBuffer() ? HR_OK : HR_ERROR;;
}

/* 处理通信关闭事件*/
ISocketListener::EnHandleResult CMainClient::OnClose(DWORD dwConnectionID)
{
    TRACE1("CNNID: %d> 关闭连接\n", dwConnectionID);

    // 清理缓冲区
    m_rcBuffer.Realloc(0);
    return HR_OK;
}

/* 处理通信错误事件 */
ISocketListener::EnHandleResult CMainClient::OnError(DWORD dwConnectionID, EnSocketOperation enOperation, int iErrorCode)
{
    TRACE3("<CNNID: %d> 网络错误 (OP: %d, CO: %d)\n", dwConnectionID, enOperation, iErrorCode);

    // 清理缓冲区
    m_rcBuffer.Realloc(0);

    return HR_OK;
}

好了，码了一个晚上的字，累啊！到此为止吧，感谢收看~

如果反应够好的话本座或许会找个时间继续发表《基于 IOCP 的通用异步 Windows TCP Socket 服务端组件的设计与实现》，晚安 ^_^

（想看源代码的朋友请狂点这里）

本文链接

通用权限管理系统组件 (GPM - General Permissions Manager) 中灵活经典的.NET2.0数据库访问组件，附源码

Wed, 15 Feb 2012 01:25:00 +0800

情人节的晚上思绪万千，想到了曾经的N次恋爱，想到现在生活，想到曾经的奋斗，想到曾经在身边的女人，人生不易终于失眠了，上一篇我们介绍了通用权限管理系统组件 (GPM - General Permissions Manager) 中超级经典的.NET2.0静态数据库访问组件两者的区别就是一个是 static 的方法，另外一个是通过接口的方式实现的，接着我们介绍更加灵活的，动态数据库5种实用方法，与上一篇的数据库访问组件结合实用会更加强大一些，真正功能强大的是没任何封装的ADO.NET，其实自己封装的往往都是有些娱乐精神的人干出来的事情。

当然这些数据库访问组件都是可以单独使用的，可以与通用权限管理系统组件无任何关联。通用权限的很多实现理念就是无关性，通用权限与数据库访问组件是无关的，数据库库访问组件就可以单独用，甚至没任何无用的代码，配置在里面。

我们直接看代码如下：

//-----------------------------------------------------------------
// All Rights Reserved , Copyright (C) 2012 , Hairihan TECH, Ltd.
//-----------------------------------------------------------------

using System;
using System.Data;
using System.Collections.Generic;

using DotNet.Utilities;
using DotNet.Business;

/// <summary>
/// DbTools2
/// 静态数据库访问的方法程序
///
/// 修改纪录
///
///        2012-02-15 版本：1.0 JiRiGaLa 整理例子程序功能。
///
/// 版本：1.0
///
/// <author>
///        <name>JiRiGaLa</name>
///        <date>2012-02-15</date>
/// </author>
/// </summary>
public partial class DbTools2 : BasePage
{
    protected void Page_Load(object sender, EventArgs e)
    {
        // 动态方法调用数据库的方法
        this.DynamicMethod();

        // 动态打开数据库的方法
        string dbConnection = "Data Source=localhost;Initial Catalog=UserCenterV36;User Id = sa ; Password = Password@1234;";
        // using (IDbHelper dbHelper = DbHelperFactory.GetHelper(CurrentDbType.Oracle))
        // using (IDbHelper dbHelper = DbHelperFactory.GetHelper(CurrentDbType.MySql))
        // using (IDbHelper dbHelper = DbHelperFactory.GetHelper(CurrentDbType.DB2))
        // using (IDbHelper dbHelper = DbHelperFactory.GetHelper(CurrentDbType.Access))
        // using (IDbHelper dbHelper = DbHelperFactory.GetHelper(CurrentDbType.SQLite))
        using (IDbHelper dbHelper = DbHelperFactory.GetHelper(CurrentDbType.SqlServer))
        {
            dbHelper.Open(dbConnection);
        }
    }

    private void DynamicMethod()
    {
        this.Fill();
        this.ExecuteNonQuery();
        this.ExecuteScalar();
        this.ExecuteReader();
    }

    /// <summary>
    /// Fill
    /// 动态方法调用数据库的方法，能有效控制数据库的开关次数
    /// </summary>
    private void Fill()
    {
        string dbConnection = "Data Source=localhost;Initial Catalog=UserCenterV36;User Id = sa ; Password = Password@1234;";
        // DotNet.Utilities.IDbHelper dbHelper = new DotNet.Utilities.DB2Helper(dbConnection);
        // DotNet.Utilities.IDbHelper dbHelper = new DotNet.Utilities.MySqlHelper(dbConnection);
        // DotNet.Utilities.IDbHelper dbHelper = new DotNet.Utilities.OleDbHelper(dbConnection);
        // DotNet.Utilities.IDbHelper dbHelper = new DotNet.Utilities.OracleHelper(dbConnection);
        // DotNet.Utilities.IDbHelper dbHelper = new DotNet.Utilities.SqLiteHelper(dbConnection);
        DotNet.Utilities.IDbHelper dbHelper = new DotNet.Utilities.SqlHelper(dbConnection);
        dbHelper.Open();

        // 1：直接执行
        string commandText = @"SELECT *
                                 FROM BASE_USER
                                WHERE DELETIONSTATECODE = 0";
        DataTable dataTable = dbHelper.Fill(commandText);

        // 2：防注入的安全的参数化运行方式执行查询
        commandText = @" SELECT *
                          FROM BASE_USER
                         WHERE CODE = " + dbHelper.GetParameter("Code")
                               + " AND DELETIONSTATECODE = " + dbHelper.GetParameter("DeletionStateCode");
        // 这里是生成安全参数的方法
        List<IDbDataParameter> dbParameters = new List<IDbDataParameter>();
        dbParameters.Add(dbHelper.MakeParameter("Code", "jirigala"));
        dbParameters.Add(dbHelper.MakeParameter("DeletionStateCode", 0));
        dataTable = dbHelper.Fill(commandText, dbParameters.ToArray());

        // 3：执行存储过程，假设也是需要传递这2个参数，类似功能的一个存储过程
        //    我们不建议用存储过程，因为会对系统移植，多数据库设计等上会遇到很多麻烦
        commandText = "GET_USER";
        dataTable = dbHelper.Fill(commandText, dbParameters.ToArray(), CommandType.StoredProcedure);
        dbHelper.Close();
    }

    /// <summary>
    /// ExecuteNonQuery
    /// 静态方法调用数据库的方法，调用事物的方式
    /// </summary>
    /// <returns>影响行数</returns>
    private int ExecuteNonQuery()
    {
        int returnValue = 0;

        string dbConnection = "Data Source=localhost;Initial Catalog=UserCenterV36;User Id = sa ; Password = Password@1234;";
        DotNet.Utilities.IDbHelper dbHelper = new DotNet.Utilities.SqlHelper(dbConnection);
        try
        {
            dbHelper.Open();
            dbHelper.BeginTransaction();

            // 1：直接执行
            string commandText = @"UPDATE BASE_USER
                                SET DELETIONSTATECODE = 0";
            returnValue = dbHelper.ExecuteNonQuery(commandText);

            // 2：防注入的安全的参数化运行方式执行查询
            commandText = @" UPDATE BASE_USER
                        SET DELETIONSTATECODE = 0
                        WHERE CODE = " + DotNet.Utilities.DbHelper.GetParameter("Code")
                                    + " AND DELETIONSTATECODE = " + DotNet.Utilities.DbHelper.GetParameter("DeletionStateCode");
            // 这里是生成安全参数的方法
            List<IDbDataParameter> dbParameters = new List<IDbDataParameter>();
            dbParameters.Add(dbHelper.MakeParameter("Code", "jirigala"));
            dbParameters.Add(dbHelper.MakeParameter("DeletionStateCode", 0));
            returnValue = dbHelper.ExecuteNonQuery(commandText, dbParameters.ToArray());

            // 3：执行存储过程，假设也是需要传递这2个参数，类似功能的一个存储过程
            //    我们不建议用存储过程，因为会对系统移植，多数据库设计等上会遇到很多麻烦
            commandText = "UPDATE_USER";
            returnValue = dbHelper.ExecuteNonQuery(commandText, dbParameters.ToArray(), CommandType.StoredProcedure);

            dbHelper.CommitTransaction();
        }
        catch (Exception ex)
        {
            dbHelper.RollbackTransaction();
            BaseExceptionManager.LogException(dbHelper, this.UserInfo, ex);
            throw ex;
        }
        finally
        {
            dbHelper.Close();
        }
        return returnValue;
    }

    /// <summary>
    /// ExecuteScalar
    /// 动态方法调用数据库的方法，支持Using的用法
    /// </summary>
    /// <returns>结果</returns>
    private object ExecuteScalar()
    {
        object returnValue = null;

        string dbConnection = "Data Source=localhost;Initial Catalog=UserCenterV36;User Id = sa ; Password = Password@1234;";
        using (DotNet.Utilities.IDbHelper dbHelper = new DotNet.Utilities.SqlHelper(dbConnection))
        {
            // 1：直接执行
            string commandText = @"SELECT CODE
                                 FROM BASE_USER
                                WHERE DELETIONSTATECODE = 0";
            returnValue = dbHelper.ExecuteScalar(commandText);

            // 2：防注入的安全的参数化运行方式执行查询
            commandText = @" SELECT CODE
                           FROM BASE_USER
                          WHERE  CODE = " + dbHelper.GetParameter("Code")
                                   + " AND DELETIONSTATECODE = " + dbHelper.GetParameter("DeletionStateCode");
            // 这里是生成安全参数的方法
            List<IDbDataParameter> dbParameters = new List<IDbDataParameter>();
            dbParameters.Add(dbHelper.MakeParameter("Code", "jirigala"));
            dbParameters.Add(dbHelper.MakeParameter("DeletionStateCode", 0));
            returnValue = dbHelper.ExecuteScalar(commandText, dbParameters.ToArray());

            // 3：执行存储过程，假设也是需要传递这2个参数，类似功能的一个存储过程
            //    我们不建议用存储过程，因为会对系统移植，多数据库设计等上会遇到很多麻烦
            commandText = "GET_USER";
            returnValue = dbHelper.ExecuteScalar(commandText, dbParameters.ToArray(), CommandType.StoredProcedure);
        }

        return returnValue;
    }

    /// <summary>
    /// ExecuteReader
    /// 动态方法调用数据库的方法，每次执行程序会自动打开关闭数据库的例子，自动会多次打开关闭
    /// </summary>
    private void ExecuteReader()
    {
        string dbConnection = "Data Source=localhost;Initial Catalog=UserCenterV36;User Id = sa ; Password = Password@1234;";
        DotNet.Utilities.IDbHelper dbHelper = new DotNet.Utilities.SqlHelper(dbConnection);

        // 1：直接执行
        string commandText = @"SELECT *
                                 FROM BASE_USER
                                WHERE DELETIONSTATECODE = 0";
        dbHelper.ExecuteReader(commandText);

        // 2：防注入的安全的参数化运行方式执行查询
        commandText = @" SELECT *
                           FROM BASE_USER
                          WHERE CODE = " + dbHelper.GetParameter("Code")
                               + " AND DELETIONSTATECODE = " + dbHelper.GetParameter("DeletionStateCode");
        // 这里是生成安全参数的方法
        List<IDbDataParameter> dbParameters = new List<IDbDataParameter>();
        dbParameters.Add(dbHelper.MakeParameter("Code", "jirigala"));
        dbParameters.Add(dbHelper.MakeParameter("DeletionStateCode", 0));
        dbHelper.ExecuteReader(commandText, dbParameters.ToArray());

        // 3：执行存储过程，假设也是需要传递这2个参数，类似功能的一个存储过程
        //    我们不建议用存储过程，因为会对系统移植，多数据库设计等上会遇到很多麻烦
        commandText = "GET_USER";
        dbHelper.ExecuteReader(commandText, dbParameters.ToArray(), CommandType.StoredProcedure);
    }
}

例子程序下载地址如下：

/Files/jirigala/CRM.rar

.NET 2.0 数据库访问层源码在这里下载：

/Files/jirigala/DotNet.Utilities.rar

本文链接

基于ArcGIS10.0和Oracle10g的空间数据管理平台十七（C#开发）-空间数据编辑（下）

Wed, 15 Feb 2012 00:27:00 +0800

我的新浪微博：http://weibo.com/freshairbrucewoo。

欢迎大家相互交流，共同提高技术。

上一篇介绍了空间数据编辑一部分实现，今天继续完成剩余的部分实现。

1.根据选择编辑任务的不同显示不同形状的鼠标，以便指示相应任务方便编辑操作

 1         /// <summary>
 2 /// 根据选择编辑任务的不同显示不同形状的鼠标，以便指示相应任务方便编辑操作
 3 /// </summary>
 4 /// <param name="sender"></param>
 5 /// <param name="e"></param>
 6         private void cboTasks_SelectedIndexChanged(object sender, EventArgs e)
 7         {
 8             // Restate 
 9             m_MapControl.MousePointer = esriControlsMousePointer.esriPointerDefault;
10             m_bEditingFtr = false;
11             m_bSketching = false;
12             m_bSelecting = false;
13             m_bMove = false;
14 
15             // Select an operation and mouse pointer depending on the user choice 
16             switch (cboTasks.SelectedIndex)
17             {
18                 case 0:
19                     // Do Nothing - the tool has already been reset 
20                     break;
21                 case 1:
22                     m_MapControl.MousePointer = esriControlsMousePointer.esriPointerCrosshair;
23                     m_bEditingFtr = true;
24                     break;
25                 case 2:
26                     m_MapControl.MousePointer = esriControlsMousePointer.esriPointerPencil;
27                     m_bSketching = true;
28                     break;
29                 case 3:
30                     m_MapControl.MousePointer = esriControlsMousePointer.esriPointerCrosshair;
31                     m_bSelecting = true;
32                     break;
33                 case 4:
34                     m_MapControl.MousePointer = esriControlsMousePointer.esriPointerHand;
35                     m_bMove = true;
36                     break;
37             } 
38 
39         }

2.选择需要的图层并且在地图编辑控件中显示出来

 1         /// <summary>
 2 /// 选择需要的图层并且在地图编辑控件中显示出来
 3 /// </summary>
 4 /// <param name="sender"></param>
 5 /// <param name="e"></param>
 6         private void cboLayers_SelectedIndexChanged(object sender, EventArgs e)
 7         {
 8             if (m_pMap == null)
 9             {
10                 return;
11             }
12 
13             // Clear any existing selection 
14             m_pMap.ClearSelection();
15             IActiveView ipActiveView;
16             ipActiveView = (IActiveView)m_pMap;
17             ipActiveView.PartialRefresh(esriViewDrawPhase.esriViewGeoSelection, null, null);
18 
19             String strLayerName = cboLayers.SelectedItem.ToString();
20             axMapControl1.Map.ClearLayers();
21             AddLayerToMapCtl(strLayerName, true);
22             m_pCurrentLayer = m_pMap.get_Layer(0);
23 
24             SetControlStates();
25         }

3.测试是否击中地图对象或地图对象上的节点

 1         /// <summary>
 2 /// 测试是否击中地图对象或地图对象上的节点
 3 /// </summary>
 4 /// <param name="tolerance">查询容差</param>
 5 /// <param name="pPoint">点击位置</param>
 6 /// <param name="pFeature">测试对象</param>
 7 /// <param name="pHitPoint">查询目标点</param>
 8 /// <param name="hitDist">目标点与点击点距离</param>
 9 /// <param name="partIndex">节索引</param>
10 /// <param name="vertexIndex">点索引</param>
11 /// <param name="vertexHit">是否击中点</param>
12 /// <returns>是否击中测试对象</returns>
13         private bool TestGeometryHit(double tolerance, IPoint pPoint, IFeature pFeature, 
14             ref IPoint pHitPoint, ref double hitDist, ref int partIndex, ref int vertexIndex, 
15             ref int vertexOffset, ref bool vertexHit)
16         {
17             // Function returns true if a feature's shape is hit and further defines 
18 // if a vertex lies within the tolorance 
19             bool bRetVal = false;
20             IGeometry pGeom = (IGeometry)pFeature.Shape;
21 
22             IHitTest pHitTest = (IHitTest)pGeom;
23             pHitPoint = new ESRI.ArcGIS.Geometry.Point();
24             bool bTrue = true;
25             // First check if a vertex was hit 
26 // 检查节点是否被击中
27             if (pHitTest.HitTest(pPoint, tolerance, esriGeometryHitPartType.esriGeometryPartVertex, 
28                 pHitPoint, ref hitDist, ref partIndex, ref vertexIndex, ref bTrue))
29             {
30                 bRetVal = true;
31                 vertexHit = true;
32             }
33             // Secondly check if a boundary was hit 
34 // 检边界是否被击中
35             else if (pHitTest.HitTest(pPoint, tolerance,  esriGeometryHitPartType.esriGeometryPartBoundary,
36                 pHitPoint, ref hitDist, ref partIndex, ref vertexIndex, ref bTrue))
37             {
38                 bRetVal = true;
39                 vertexHit = false;
40             }
41 
42             // Calculate offset to vertexIndex for multipatch geometries 
43             if (partIndex > 0)
44             {
45                 IGeometryCollection pGeomColn = (IGeometryCollection)pGeom;
46                 vertexOffset = 0;
47                 for (int i = 0; i < partIndex; i++)
48                 {
49                     IPointCollection pPointColn = (IPointCollection)pGeomColn.get_Geometry(i);
50                     vertexOffset = vertexOffset + pPointColn.PointCount;
51                 }
52             }
53 
54             return bRetVal;
55         }

4.向图层中更新新的地图对象，并使之处于选中状态

 1         /// <summary>
 2 /// 向图层中更新新的地图对象，并使之处于选中状态
 3 /// </summary>
 4 /// <param name="pFeature"></param>
 5 /// <param name="pGeometry"></param>
 6         private void UpdateFeature(IFeature pFeature, IGeometry pGeometry)
 7         {
 8             // Make sure we are actually editing this layer. If not give a warning. 
 9             IDataset pDataset = (IDataset)pFeature.Class;
10             IWorkspaceEdit pWorkspaceEdit = (IWorkspaceEdit)pDataset.Workspace;
11             if (!pWorkspaceEdit.IsBeingEdited())
12             {
13                 System.Windows.Forms.MessageBox.Show("This feature is in a layer not in edit mode. \nEdit cannot be made.Start edit and try again.",
14                     "Error", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
15             }
16 
17             // If all tests succeed allow feature edits to be saved 
18             pWorkspaceEdit.StartEditOperation();
19             pFeature.Shape = pGeometry;
20             pFeature.Store();
21             pWorkspaceEdit.StopEditOperation();
22         }

5.屏幕坐标转换为地图坐标

 1         /// <summary>
 2 /// 屏幕坐标转换为地图坐标
 3 /// </summary>
 4 /// <param name="pActiveView">地图</param>
 5 /// <param name="pixelUnits">屏幕坐标</param>
 6 /// <returns>地图坐标</returns>
 7         private double ConvertPixelsToMapUnits(IActiveView pActiveView, double pixelUnits)
 8         {
 9             // Uses the ratio of the size of the map in pixels to map units to do the conversion 
10             IPoint p1 = pActiveView.ScreenDisplay.DisplayTransformation.VisibleBounds.UpperLeft;
11             IPoint p2 = pActiveView.ScreenDisplay.DisplayTransformation.VisibleBounds.UpperRight;
12             int x1, x2, y1, y2;
13             pActiveView.ScreenDisplay.DisplayTransformation.FromMapPoint(p1, out x1, out y1);
14             pActiveView.ScreenDisplay.DisplayTransformation.FromMapPoint(p2, out x2, out y2);
15             double pixelExtent = x2 - x1;
16             double realWorldDisplayExtent = pActiveView.ScreenDisplay.DisplayTransformation.VisibleBounds.Width;
17             double sizeOfOnePixel = realWorldDisplayExtent / pixelExtent;
18             return pixelUnits * sizeOfOnePixel;
19         }

6.处理地图控件上的目标按下事件

 1         private void axMapControl1_OnMouseDown(object sender, IMapControlEvents2_OnMouseDownEvent e)
 2         {
 3             //首先判断当前用户选择了何种任务，并去完成相应的任务；如果没有选择任何任务，
 4 //即cboTasks的选项为没有任务时，该事件处理程序用于放大、缩小地图，鼠标左键
 5 //用于放大，其他键用于缩小
 6             m_pMap.ClearSelection();//清除地图中已选的要素
 7             
 8             if (m_bSketching)
 9             {
10                 //新建要素任务处理
11                 SketchMouseDown(e.x, e.y);
12             }
13             else if (m_bSelecting)
14             {
15                 //选择要素任务处理
16                 SelectMouseDown(e.x, e.y);
17             }
18             else if (m_bEditingFtr)
19             {
20                 //编辑要素任务处理
21                 EditFeature(e.x, e.y);
22             }
23             else if (m_bMove)
24             {
25                 //移动要素
26                 MoveFeatureMouseDown(e.x, e.y);
27             }
28             else
29             {
30                 // Zoom in/out depending on which button was pressed 
31                 IActiveView pActiveView = (IActiveView)m_pMap;
32                 IEnvelope pEnvelope = pActiveView.Extent;
33                 ESRI.ArcGIS.Geometry.Point pnt = new ESRI.ArcGIS.Geometry.Point();
34                 IPoint iPnt = pnt;
35                 iPnt.X = e.mapX;
36                 iPnt.Y = e.mapY;
37                 pEnvelope.CenterAt(iPnt);
38                 if (e.button == 1) // left button 
39                 {
40                     //放大视图
41                     pEnvelope.Expand(0.5, 0.5, true);
42                 }
43                 else
44                 {
45                     //缩小视图
46                     pEnvelope.Expand(2, 2, true);
47                 }
48                 pActiveView.Extent = pEnvelope;
49                 pActiveView.Refresh();
50             } 
51 
52         }

7.处理地图控件上的鼠标移动事件

 1         private void axMapControl1_OnMouseMove(object sender, IMapControlEvents2_OnMouseMoveEvent e)
 2         {
 3             if (m_bSketching)
 4             {
 5                 //新建要素任务处理
 6                 SketchMouseMove(e.x, e.y);
 7             }
 8             else if (m_bEditingFtr)
 9             {
10                 //编辑要素任务处理
11                 FtrEditMouseMove(e.x, e.y);
12             }
13             else if (m_bMove)
14             {
15                 //移动要素任务处理
16                 MoveFeatureMouseMove(e.x, e.y);
17             }
18 
19         }

8.处理地图控件上的鼠标按下事件

 1         private void axMapControl1_OnMouseUp(object sender, IMapControlEvents2_OnMouseUpEvent e)
 2         {
 3             if (m_bEditingFtr)
 4             {
 5                 //结束编辑任务
 6                 EndFtrEdit(e.x, e.y);
 7             }
 8             else if (m_bMove)
 9             {
10                 //结束移动要素任务
11                 MoveFeatureEnd();
12             }
13 
14         }

9.新建对象方法：当前图层为点图层时，每调用一次就新点一个点对象，当前图层为线图层或面图层时，第一次调用开始新建对象，并添加当前点，以后每调用一次，即向新对象中添加一个点,调用NewFeatureEnd方法完成对象创建。

 1         /// <summary>
 2 /// 新建对象方法
 3 /// 当前图层为点图层时，每调用一次就新点一个点对象
 4 /// 当前图层为线图层或面图层时，第一次调用开始新建对象，并添加当前点，
 5 /// 以后每调用一次，即向新对象中添加一个点,调用NewFeatureEnd方法完成对象创建
 6 /// 在Map.MouseDown事件中调用本方法
 7 /// </summary>
 8 /// <param name="x">鼠标X坐标，屏幕坐标</param>
 9 /// <param name="y">鼠标Y坐标，屏幕坐标</param>
10         private void SketchMouseDown(int x, int y)
11         {
12             // Starts a new sketch or adds a point to an existing one, of a type 
13 // determined by the current layer selected in the layers combo. 
14 
15 // Can only sketch on GeoFeature layers 
16             if (m_pCurrentLayer == null)
17             {
18                 return;
19             }
20             if ((IGeoFeatureLayer)m_pCurrentLayer == null)
21             {
22                 return;
23             }
24 
25             // Get the mouse down point in map coordinates 
26             IFeatureLayer pFeatureLayer = (IFeatureLayer)m_pCurrentLayer;
27             if (pFeatureLayer.FeatureClass == null)
28             {
29                 return;
30             }
31             IActiveView pActiveView = (IActiveView)m_pMap;
32             IPoint pPoint = pActiveView.ScreenDisplay.DisplayTransformation.ToMapPoint(x, y);
33 
34             // if (this is a fresh sketch) create an appropriate feedback object, 
35 // otherwise extent the existing feedback 
36 // 如果是新开始创建的对象，则相应的创建一个新的Feedback对象；
37 // 否则，向已存在的Feedback对象中加点
38             if (!m_bInUse)
39             {
40                 m_pMap.ClearSelection();  //清除地图选中对象
41                 switch (pFeatureLayer.FeatureClass.ShapeType)
42                 {
43                     case esriGeometryType.esriGeometryPoint:
44                         CreateFeature(pPoint);
45                         break;
46                     case esriGeometryType.esriGeometryMultipoint:
47                         m_bInUse = true;
48                         m_pFeedback = new NewMultiPointFeedback();
49                         INewMultiPointFeedback pMPFeed = (INewMultiPointFeedback)m_pFeedback;
50                         m_pPointCollection = new Multipoint();
51                         pMPFeed.Start(m_pPointCollection, pPoint);
52                         break;
53                     case esriGeometryType.esriGeometryPolyline:
54                         m_bInUse = true;
55                         m_pFeedback = new NewLineFeedback();
56                         INewLineFeedback pLineFeed = (INewLineFeedback)m_pFeedback;
57                         pLineFeed.Start(pPoint);
58                         break;
59                     case esriGeometryType.esriGeometryPolygon:
60                         m_bInUse = true;
61                         m_pFeedback = new NewPolygonFeedback();
62                         INewPolygonFeedback pPolyFeed = (INewPolygonFeedback)m_pFeedback;
63                         pPolyFeed.Start(pPoint);
64                         break;
65                 }
66                 if (m_pFeedback != null)
67                 {
68                     m_pFeedback.Display = pActiveView.ScreenDisplay;
69                 }
70             }
71             else
72             {
73                 if (m_pFeedback is INewMultiPointFeedback)
74                 {
75                     object Missing = Type.Missing;
76                     m_pPointCollection.AddPoint(pPoint, ref Missing, ref Missing);
77                 }
78                 else if (m_pFeedback is INewLineFeedback)
79                 {
80                     INewLineFeedback pLineFeed = (INewLineFeedback)m_pFeedback;
81                     pLineFeed.AddPoint(pPoint);
82                 }
83                 else if (m_pFeedback is INewPolygonFeedback)
84                 {
85                     INewPolygonFeedback pPolyFeed = (INewPolygonFeedback)m_pFeedback;
86                     pPolyFeed.AddPoint(pPoint);
87                 }
88             }
89         }

10.新建对象过程中鼠标移动方法,产生Track效果，在Map.MouseMove事件中调用本方法

 1         /// <summary>
 2 /// 新建对象过程中鼠标移动方法,产生Track效果
 3 /// 在Map.MouseMove事件中调用本方法
 4 /// </summary>
 5 /// <param name="x">鼠标X坐标，屏幕坐标</param>
 6 /// <param name="y">鼠标Y坐标，屏幕坐标</param>
 7         private void SketchMouseMove(int x, int y)
 8         {
 9             if (!m_bInUse || m_pFeedback == null)
10             {
11                 return;
12             }
13 
14             // Move the feedback envelope and store the current mouse position 
15             IActiveView pActiveView = (IActiveView)m_pMap;
16             m_pFeedback.MoveTo(pActiveView.ScreenDisplay.DisplayTransformation.ToMapPoint(x, y));
17             m_pPoint = pActiveView.ScreenDisplay.DisplayTransformation.ToMapPoint(x, y);
18         }

11.完成新建对象，取得绘制的对象，并添加到图层中：建议在Map.DblClick或Map.MouseDown(Button = 2)事件中调用本方法

 1         /// <summary>
 2 /// 完成新建对象，取得绘制的对象，并添加到图层中
 3 /// 建议在Map.DblClick或Map.MouseDown(Button = 2)事件中调用本方法
 4 /// </summary>
 5         private void EndSketch()
 6         {
 7             IGeometry pGeom = null;
 8             IPointCollection pPointCollection = null;
 9 
10             // Create a new feature if possible 
11             if (m_pFeedback is INewMultiPointFeedback)
12             {
13                 INewMultiPointFeedback pMPFeed = (INewMultiPointFeedback)m_pFeedback;
14                 pMPFeed.Stop();
15                 pGeom = (IGeometry)m_pPointCollection;
16             }
17             else if (m_pFeedback is INewLineFeedback)
18             {
19                 INewLineFeedback pLineFeed = (INewLineFeedback)m_pFeedback;
20                 pLineFeed.AddPoint(m_pPoint);
21                 IPolyline pPolyLine = pLineFeed.Stop();
22                 pPointCollection = (IPointCollection)pPolyLine;
23                 if (pPointCollection.PointCount < 2)
24                     MessageBox.Show("至少输入两个节点.", "错误的线几何对象", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
25                 else
26                     pGeom = (IGeometry)pPointCollection;
27             }
28             else if (m_pFeedback is INewPolygonFeedback)
29             {
30                 INewPolygonFeedback pPolyFeed = (INewPolygonFeedback)m_pFeedback;
31                 pPolyFeed.AddPoint(m_pPoint);
32                 IPolygon pPolygon = pPolyFeed.Stop();
33                 if (pPolygon != null)
34                     pPointCollection = (IPointCollection)pPolygon;
35                 if (pPointCollection.PointCount < 3)
36                     MessageBox.Show("至少输入三个节点.", "错误的线几何对象", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
37                 else
38                     pGeom = (IGeometry)pPointCollection;
39             }
40             CreateFeature(pGeom);
41             m_pFeedback = null;
42             m_bInUse = false;
43         }

12.查询当前图层中鼠标位置处的地图对象，建议在Map.MouseDown事件中调用本方法

 1         /// <summary>
 2 /// 查询当前图层中鼠标位置处的地图对象
 3 /// 建议在Map.MouseDown事件中调用本方法
 4 /// </summary>
 5 /// <param name="x">鼠标X坐标，屏幕坐标</param>
 6 /// <param name="y">鼠标Y坐标，屏幕坐标</param>
 7         private void SelectMouseDown(int x, int y)
 8         {
 9             // Searches the map for features at the given point in the current layer 
10 // and selects them 
11 
12             m_pMap.ClearSelection();//清除地图中已选的要素
13             if (m_pCurrentLayer == null)
14             {
15                 return;
16             }
17 
18             if ((IGeoFeatureLayer)m_pCurrentLayer == null)
19             {
20                 return;
21             }
22 
23             // Get the feature layer and class of the current layer 
24             IFeatureLayer pFeatureLayer = (IFeatureLayer)m_pCurrentLayer;
25             IFeatureClass pFeatureClass = pFeatureLayer.FeatureClass;
26             if (pFeatureClass == null)
27             {
28                 return;
29             }
30 
31             // Get the mouse down position in map coordinates 
32             IActiveView pActiveView = (IActiveView)m_pMap;
33             IPoint pPoint = pActiveView.ScreenDisplay.DisplayTransformation.ToMapPoint(x, y);
34             IGeometry pGeometry = pPoint;
35 
36             // Use a four pixel buffer around the cursor for feature search 
37 // 设置查询缓冲区
38             double length = ConvertPixelsToMapUnits(pActiveView, 4);
39             ITopologicalOperator pTopo = (ITopologicalOperator)pGeometry;
40             IGeometry pBuffer = pTopo.Buffer(length);
41             pGeometry = (IGeometry)pBuffer.Envelope;
42 
43             // up a Filter specific to this layer  
44 //设置过滤器对象
45             ISpatialFilter pSpatialFilter = new SpatialFilter();
46             pSpatialFilter.Geometry = pGeometry;
47             switch (pFeatureClass.ShapeType)
48             {
49                 case esriGeometryType.esriGeometryPoint:
50                     pSpatialFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelContains;
51                     break;
52                 case esriGeometryType.esriGeometryPolyline:
53                     pSpatialFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelCrosses;
54                     break;
55                 case esriGeometryType.esriGeometryPolygon:
56                     pSpatialFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects;
57                     break;
58             }
59             pSpatialFilter.GeometryField = pFeatureClass.ShapeFieldName;
60             IQueryFilter pFilter = pSpatialFilter;
61 
62             // Do the search 
63 // 查询
64             IFeatureCursor pCursor = pFeatureLayer.Search(pFilter, false);
65 
66             // and select the features on the map 
67 // 在地图上高亮显示查询结果
68             IFeature pFeature = pCursor.NextFeature();
69             while (pFeature != null)
70             {
71                 m_pMap.SelectFeature(m_pCurrentLayer, pFeature);
72                 pFeature = pCursor.NextFeature();
73             }
74             pActiveView.PartialRefresh(esriViewDrawPhase.esriViewGeoSelection, null, null);
75         }

13.编辑当前图层中鼠标击中的地图对象(开始编辑), 如果为点对象，可进行位置移动，如果为线对象或面对象，可进行节点编辑：建议在Map.MouseDown事件中调用本方法

  1         /// <summary>
  2 /// 编辑当前图层中鼠标击中的地图对象(开始编辑),
  3 /// 如果为点对象，可进行位置移动，如果为线对象或面对象，可进行节点编辑
  4 /// 建议在Map.MouseDown事件中调用本方法
  5 /// </summary>
  6 /// <param name="x">鼠标X坐标，屏幕坐标</param>
  7 /// <param name="y">鼠标Y坐标，屏幕坐标</param>
  8 /// <returns></returns>
  9         private void EditFeature(int x, int y)
 10         {
 11             // Searches for features under the coordinate provided and starts an edit 
 12 // operation on the first one found. 
 13             IPoint pHitPoint = null;
 14             double hitDist = 0;
 15             int partIndex = 0;
 16             int vertexIndex = 0;
 17             int vertexOffset = 0;
 18             bool vertex = false;
 19 
 20             // Use the first feature in the selection 
 21 // 取得鼠标击中的第一个对象
 22             SelectMouseDown(x, y);
 23             IEnumFeature pSelected = (IEnumFeature)m_pMap.FeatureSelection;
 24             IFeature pFeature = pSelected.Next();
 25             if (pFeature == null)
 26             {
 27                 return;
 28             }
 29 
 30             IActiveView pActiveView = (IActiveView)m_pMap;
 31             IPoint pPoint = pActiveView.ScreenDisplay.DisplayTransformation.ToMapPoint(x, y);
 32 
 33             // Tolerance in pixels for line hits 
 34 // 节点空间查询容差
 35             double tol = ConvertPixelsToMapUnits(pActiveView, 4);
 36 
 37             // The feedback action / edit action depends on the geometry type 
 38 // and the location of point within the geometry 
 39             IGeometry pGeom = pFeature.Shape;
 40             IObjectClass pObjectClass = pFeature.Class;
 41             m_pEditFeature = pFeature;
 42 
 43             switch (pGeom.GeometryType)
 44             {
 45                 case esriGeometryType.esriGeometryPoint:
 46                     m_pFeedback = new MovePointFeedback();
 47                     m_pFeedback.Display = pActiveView.ScreenDisplay;
 48                     IMovePointFeedback pPointMove = (IMovePointFeedback)m_pFeedback;
 49                     pPointMove.Start((IPoint)pGeom, pPoint);
 50                     break;
 51 
 52                 case esriGeometryType.esriGeometryPolyline:
 53                     if (TestGeometryHit(tol, pPoint, pFeature, ref pHitPoint, ref hitDist,
 54                         ref partIndex, ref vertexIndex, ref vertexOffset, ref vertex))
 55                     {
 56                         if (!vertex)
 57                         {
 58                             // Get the path, add a point to it and vertex edit that newly added point 
 59                             IGeometryCollection pGeomColn = (IGeometryCollection)pGeom;
 60                             IPath pPath = (IPath)pGeomColn.get_Geometry(partIndex);
 61                             IPointCollection pPointColn = (IPointCollection)pPath;
 62                             long numVertices = pPointColn.PointCount;
 63 
 64                             object Missing = Type.Missing;
 65                             object val;
 66                             if (vertexIndex == 0)
 67                             {
 68                                 val = 1;
 69                                 pPointColn.AddPoint(pPoint, ref val, ref Missing);
 70                             }
 71                             else
 72                             {
 73                                 val = vertexIndex;
 74                                 pPointColn.AddPoint(pPoint, ref Missing, ref val);
 75                             }
 76 
 77                             // Reset the index pointer to the new index 
 78                             TestGeometryHit(tol, pPoint, pFeature, ref pHitPoint, ref hitDist, ref partIndex, ref vertexIndex, ref vertexOffset, ref vertex);
 79                         }
 80                         m_pFeedback = new LineMovePointFeedback();
 81                         m_pFeedback.Display = pActiveView.ScreenDisplay;
 82                         ILineMovePointFeedback pLineMove = (ILineMovePointFeedback)m_pFeedback;
 83                         pLineMove.Start((IPolyline)pGeom, vertexIndex, pPoint);
 84                     }
 85                     else
 86                     {
 87                         return;
 88                     }
 89                     //
 90                     break;
 91 
 92                 case esriGeometryType.esriGeometryPolygon:
 93                     if (TestGeometryHit(tol, pPoint, pFeature, ref pHitPoint, ref hitDist,
 94                         ref partIndex, ref vertexIndex, ref vertexOffset, ref vertex))
 95                     {
 96                         if (!vertex)
 97                         {
 98                             // Get the path, add a point to it and vertex edit that newly added point 
 99                             IGeometryCollection pGeomColn = (IGeometryCollection)pGeom;
100                             IPath pPath = (IPath)pGeomColn.get_Geometry(partIndex);
101                             IPointCollection pPointColn = (IPointCollection)pPath;
102                             long numVertices = pPointColn.PointCount;
103 
104                             // Rethe index pointer to the new index 
105                             object Missing = Type.Missing;
106                             object val;
107                             if (vertexIndex == 0)
108                             {
109                                 val = 1;
110                                 pPointColn.AddPoint(pPoint, ref val, ref Missing);
111                             }
112                             else
113                             {
114                                 val = vertexIndex;
115                                 pPointColn.AddPoint(pPoint, ref Missing, ref val);
116                             }
117 
118                             // Reset the index pointer to the new index 
119                             TestGeometryHit(tol, pPoint, pFeature, ref pHitPoint, ref hitDist, ref partIndex, ref vertexIndex, ref vertexOffset, ref vertex);
120                         }
121                         m_pFeedback = new PolygonMovePointFeedback();
122                         m_pFeedback.Display = pActiveView.ScreenDisplay;
123                         IPolygonMovePointFeedback pPolyMove = (IPolygonMovePointFeedback)m_pFeedback;
124                         pPolyMove.Start((IPolygon)pGeom, vertexIndex + vertexOffset, pPoint);
125                     }
126                     else
127                         return;
128                     break;
129             }
130 
131             return;
132         }

14.编辑地图对象过程中的鼠标移动事件, 如果为点对象，进行位置移动；如果为线对象或面对象，进行节点移动：建议在Map.MouseMove事件中调用本方法

 1         /// <summary>
 2 /// 编辑地图对象过程中的鼠标移动事件,
 3 /// 如果为点对象，进行位置移动
 4 /// 如果为线对象或面对象，进行节点移动
 5 /// 建议在Map.MouseMove事件中调用本方法
 6 /// </summary>
 7 /// <param name="x">鼠标X坐标，屏幕坐标</param>
 8 /// <param name="y">鼠标Y坐标，屏幕坐标</param>
 9         private void FtrEditMouseMove(int x, int y)
10         {
11             // Moves the edit feedback object along with the mouse. 
12             if (m_pFeedback == null)
13             {
14                 return;
15             }
16 
17             IActiveView pActiveView = (IActiveView)m_pMap;
18             IPoint pPoint = pActiveView.ScreenDisplay.DisplayTransformation.ToMapPoint(x, y);
19             m_pFeedback.MoveTo(pPoint);
20         }

15.结束feature的编辑

 1         /// <summary>
 2 /// 结束feature的编辑
 3 /// </summary>
 4 /// <param name="x"></param>
 5 /// <param name="y"></param>
 6         private void EndFtrEdit(int x, int y)
 7         {
 8             // Uses the feedback object//s geometry to rethe geometry on the feature 
 9 // being edited. 
10 
11 // if (no feedback no edit 
12             if (m_pFeedback == null)
13             {
14                 return;
15             }
16 
17             IActiveView pActiveView = (IActiveView)m_pMap;
18             IPoint pPoint = pActiveView.ScreenDisplay.DisplayTransformation.ToMapPoint(x, y);
19 
20             if (m_pFeedback is IMovePointFeedback)
21             {
22                 IMovePointFeedback pPointMove = (IMovePointFeedback)m_pFeedback;
23                 IGeometry pGeometry = pPointMove.Stop();
24                 UpdateFeature(m_pEditFeature, pGeometry);
25             }
26             else if (m_pFeedback is ILineMovePointFeedback)
27             {
28                 ILineMovePointFeedback pLineMove = (ILineMovePointFeedback)m_pFeedback;
29                 IGeometry pGeometry = pLineMove.Stop();
30                 UpdateFeature(m_pEditFeature, pGeometry);
31             }
32             else if (m_pFeedback is IPolygonMovePointFeedback)
33             {
34                 IPolygonMovePointFeedback pPolyMove = (IPolygonMovePointFeedback)m_pFeedback;
35                 IGeometry pGeometry = pPolyMove.Stop();
36                 UpdateFeature(m_pEditFeature, pGeometry);
37             }
38 
39             m_pFeedback = null;
40             pActiveView.Refresh();
41         }

16.移动当前图层中鼠标击中地图对象的位置（开始移动）：建议在Map.MouseDown事件中调用本方法

 1         /// <summary>
 2 /// 移动当前图层中鼠标击中地图对象的位置（开始移动）
 3 /// 建议在Map.MouseDown事件中调用本方法
 4 /// </summary>
 5 /// <param name="x">鼠标X坐标，屏幕坐标</param>
 6 /// <param name="y">鼠标Y坐标，屏幕坐标</param>
 7 /// <returns></returns>
 8         public bool MoveFeatureMouseDown(int x, int y)
 9         {
10             try
11             {
12                 m_pMap.ClearSelection();
13 
14                 SelectMouseDown(x, y);
15                 IEnumFeature pSelected = (IEnumFeature)m_pMap.FeatureSelection;
16                 IFeature pFeature = pSelected.Next();
17                 if (pFeature == null) return false;
18 
19                 IActiveView pActiveView = (IActiveView)m_pMap;
20                 IPoint pPoint = pActiveView.ScreenDisplay.DisplayTransformation.ToMapPoint(x, y);
21 
22                 IGeometry pGeom = pFeature.Shape;
23                 m_pEditFeature = pFeature;
24 
25                 switch (pGeom.GeometryType)
26                 {
27                     case esriGeometryType.esriGeometryPoint:
28                         m_pFeedback = new MovePointFeedbackClass();
29                         m_pFeedback.Display = pActiveView.ScreenDisplay;
30                         IMovePointFeedback pPointMove = (IMovePointFeedback)m_pFeedback;
31                         pPointMove.Start((IPoint)pGeom, pPoint);
32                         break;
33                     case esriGeometryType.esriGeometryPolyline:
34 
35                         m_pFeedback = new MoveLineFeedbackClass();
36                         m_pFeedback.Display = pActiveView.ScreenDisplay;
37                         IMoveLineFeedback pLineMove = (IMoveLineFeedback)m_pFeedback;
38                         pLineMove.Start((IPolyline)pGeom, pPoint);
39                         break;
40                     case esriGeometryType.esriGeometryPolygon:
41                         m_pFeedback = new MovePolygonFeedbackClass();
42                         m_pFeedback.Display = pActiveView.ScreenDisplay;
43                         IMovePolygonFeedback pPolyMove = (IMovePolygonFeedback)m_pFeedback;
44                         pPolyMove.Start((IPolygon)pGeom, pPoint);
45                         break;
46                 }
47                 return true;
48             }
49             catch (Exception e)
50             {
51                 Console.WriteLine(e.Message.ToString());
52                 return false;
53             }
54         }

17.移动地图对象过程中的鼠标移动事件：建议在Map.MouseMove事件中调用本方法

 1         /// <summary>
 2 /// 移动地图对象过程中的鼠标移动事件
 3 /// 建议在Map.MouseMove事件中调用本方法
 4 /// </summary>
 5 /// <param name="x">鼠标X坐标，屏幕坐标</param>
 6 /// <param name="y">鼠标Y坐标，屏幕坐标</param>
 7         public void MoveFeatureMouseMove(int x, int y)
 8         {
 9             try
10             {
11                 if (m_pFeedback == null) return;
12 
13                 IActiveView pActiveView = (IActiveView)m_pMap;
14                 IPoint pPoint = pActiveView.ScreenDisplay.DisplayTransformation.ToMapPoint(x, y);
15                 m_pFeedback.MoveTo(pPoint);
16             }
17             catch (Exception e)
18             {
19                 Console.WriteLine(e.Message.ToString());
20             }
21         }

18.完成地图对象移动，取得移动后的对象，并将其更新到图层中：建议在Map.MouseUp事件中调用本方法

 1         /// <summary>
 2 /// 完成地图对象移动，取得移动后的对象，并将其更新到图层中
 3 /// 建议在Map.MouseUp事件中调用本方法
 4 /// </summary>
 5         public void MoveFeatureEnd()
 6         {
 7             IGeometry pGeometry;
 8 
 9             try
10             {
11                 if (m_pFeedback == null) return;
12 
13                 if (m_pFeedback is IMovePointFeedback)
14                 {
15                     IMovePointFeedback pPointMove = (IMovePointFeedback)m_pFeedback;
16                     pGeometry = pPointMove.Stop();
17                     UpdateFeature(m_pEditFeature, pGeometry);
18                 }
19                 else if (m_pFeedback is IMoveLineFeedback)
20                 {
21                     IMoveLineFeedback pLineMove = (IMoveLineFeedback)m_pFeedback;
22                     pGeometry = pLineMove.Stop();
23                     UpdateFeature(m_pEditFeature, pGeometry);
24                 }
25                 else if (m_pFeedback is IMovePolygonFeedback)
26                 {
27                     IMovePolygonFeedback pPolyMove = (IMovePolygonFeedback)m_pFeedback;
28                     pGeometry = pPolyMove.Stop();
29                     UpdateFeature(m_pEditFeature, pGeometry);
30                 }
31 
32                 m_pFeedback = null;
33                 IActiveView pActiveView = (IActiveView)m_pMap;
34                 pActiveView.Refresh();
35             }
36             catch (Exception e)
37             {
38                 Console.WriteLine(e.Message.ToString());
39             }
40         }

总结：终于结束了，感觉通过可视化来编辑空间数据需要做太多的工作，上面把要做的工作几乎都秒到了，至于具体流程这个只需要简单组织一下逻辑就可以了。更强大的空间数据编辑功能有待于我们更加活跃的思维去创造！OK！今天就到这里了吧！情人节已过，各位coder们赶快回来编程吧！

本文链接

程序员第二定律：量化管理在程序员身上永无可能

Wed, 15 Feb 2012 00:21:00 +0800

恰如标题，第二定律表示为：在思维可以精确量化前，量化管理在程序员身上永无可能。

这次估计会有争议，所以这里给出具体的逻辑链以及对应的分析。

逻辑链：

软件是一种固化的思维 →思维的本质是概念和逻辑 → 概念和逻辑无法直接度量和精确度量 → 度量过程中需要很多的主观判断 → 以目标为导向的，个人中心的量化管理（相关的激励和惩罚）将崩溃

具体分析：

公平公正是管理的基石，为达成这一目的很多人会想到量化管理，但量化管理的基石却往往被忽略。

对人进行量化管理的基石是：量化后的数字主要受个人表现这一个因素的影响，否则将产生巨大的不公正，并对个人工作意愿产生不良影响，是真正的事与愿违。

好比说，不同的工人在同等条件下生产杯子，一个人一小时生产5个，一个人1小时生产6个，那显然后者要好于前者。这时，5和6可以用来比较的前提是两个人的生产条件相同，比如生产工艺等。在这种情况下，量化后的数字为个人表现的函数，因此量化管理基本上是公正的。

这时可以进一步来考虑下面的情形：两个人同时生产杯子，厂方安排一个人用工艺a，另一个人用工艺b，这个时候前者一小时生产5个，后者1小时生产6个。这个时候单纯比较5和6事实上是不公平的，因为这1个杯子的差距可能是工艺造成的。

大多时候，软件的情况比后一个情形还要糟糕一些。

在软件开发中，往往既没有办法清楚的界定一个人的输入，也没办法清楚的界定一个人的输出。

软件开发的输入是需求，但同一个需求不需要做多次，所以对需求自身的复杂程度眼下来看还只能依赖判断，而不能精确度量。

软件开发的输出是代码，而代码自身属于固化后的思维。在度量思维时，多少、大小、长短、厚薄这类惯常的度量方向，并不具有多大意义。就好比说，不能讲一个人代码写的越多贡献就越大一样。

诚然思维的表现形式则是可以度量的，我们可以通过页数来度量一本书的厚薄，通过分钟来度量一部电影的长短，通过代码行来度量软件，但这种度量所反映的内涵是有限度的，精度也是有限度的。最终结果很可能是人员之间的差距是由误差或其他非主观因素造成的，而不是由个人工作好坏所造成的。

总结来看，在软件开发中，数字含义的模糊性会导致使用数字进行评价包含非常多的不公正，这种不公正会对工作意愿构成致命伤害。所以个人层面的量化管理在软件开发面前，必然崩溃。

补充说明：

为避免矫枉过正，最后需要强调的是：并不是说项目管理中不需要收集数据，只是说在软件这个行业中，各种数据的精度天生是有限的，因此必须用在允许有限精度的工作上（估算、任务安排等），而不能用在对人进行评价、对项目进行评价这样需要高精度数据的工作上。

这条定律的推论可以无限多，影响到管理，流程乃至估算，这里就不列了。

关联文章：

程序员第一定律：关于技能和收入

本文链接

[Nhibernate] Inverse

Wed, 15 Feb 2012 00:18:00 +0800

什么是inverse?

通过inverse的设置来决定是由哪端来维护对象之间的关系的

双向many-to-one

Employee.hbm.xml

<?xml version="1.0" encoding="utf-8" ?>
<hibernate-mapping
  xmlns="urn:nhibernate-mapping-2.2"
  namespace="ZiyeNhi.Entities"
  assembly="ZiyeNhi.Entities">

  <class name="Employee" table="Emp">
    <id name="EmpId" column="EmpId" type="int">
      <generator class="identity">
      </generator>
    </id>

    <property name="EmpName" column="EmpName" type="string" length="50"></property>

    <many-to-one name="Department" class="Department" column="DepId" lazy="proxy"></many-to-one>
  </class>

</hibernate-mapping>

Department.hbm.xml

<?xml version="1.0" encoding="utf-8" ?>
<hibernate-mapping
  xmlns="urn:nhibernate-mapping-2.2"
  namespace="ZiyeNhi.Entities"
  assembly="ZiyeNhi.Entities">

  <class name="Department" table="Dep">
    <id name="DepId" column="DepId" type="int">
      <generator class="identity">
      </generator>
    </id>
    <property name="DepName" column="DepName" type="string" length="50"></property>

    
    <set name="Employees" table="Emp" inverse="true" lazy="true" >
      <key column="DepId" ></key>
      <one-to-many class="Employee"/>
    </set>
  </class>

</hibernate-mapping>

一般来说我们都习惯

one端(department) inverse="true";（对应上面的department.hbm.xml）

many端(Employee) inverse="false";(对应上面的employee.hbm.xml)

这样我们就可以用department属性来维护二者的关系

[Test]
        public void SaveDepartment()
        {
            using (ISession session = this.sessionFactory.OpenSession())
            {
                var emp1 = new Employee() { EmpName = "xr" };
                var emp2 = new Employee() { EmpName = "wxr" };
                var department = new Department() { DepName = "QQ" };
                emp1.Department = department;
                emp2.Department = department;
                ITransaction transaction = session.BeginTransaction();
                try
                {
                    session.Save(department);
                    session.Save(emp1);
                    session.Save(emp2);
                    transaction.Commit();
                }
                catch (Exception ex)
                {
                    transaction.Rollback();
                    throw ex;
                }
            }
        }

测试结果

生成了3条insert语句一条是插入department,另外两条是插入Employee的他们二者的关系是由Employee对象的department属性来维护的

为什么我们一般都要这么做呢

第一：如果我们通过Department.Employee.add(emp对象) 这种关系来维护的话，那么当前部门下有N个employee lazy=“true”的时候是不是很浪费资源？

第二：数据模型中一般情况下对象关系都是由子表体现出来（看department表中只有DepId,DepName,而在employee表中可以看到外键depId).那么我们在对象模型中也推荐子对象来维护关系.

第三：期待补充.

Inverse属性在many-to-one中的应用

1.经测试。如果两端都设置为inverse="true"那么两端都不会维护关系

2.两端都为inverse="false"的情况下

3.one端为false,many端为true

4.one端为true,many端为false

围绕2 3 4 来说

两端都为false

[Test]
        public void SaveDepartment()
        {
            using (ISession session = this.sessionFactory.OpenSession())
            {
                var emp1 = new Employee() { EmpName = "xr" };
                var emp2 = new Employee() { EmpName = "wxr" };
                var department = new Department() { DepName = "QQ" };
                //以下两句为A组合 Employee对象来维护关系
                emp1.Department = department;
                emp2.Department = department;
                //以下两句为B组合 Department对象来维护关系
                //department.Employees.Add(emp1);
                //department.Employees.Add(emp2);
                ITransaction transaction = session.BeginTransaction();
                try
                {
                    session.Save(department);
                    session.Save(emp1);
                    session.Save(emp2);
                    transaction.Commit();
                }
                catch (Exception ex)
                {
                    transaction.Rollback();
                    throw ex;
                }
            }
        }

测试结果

代码中维持关系的是employee对象或者说是employee对象下的Department属性

生成了3条语句（3条insert 先插入department 然后通过插入department返回的ID 来插入2条employee）

将A组合切换B组合

[Test]
        public void SaveDepartment()
        {
            using (ISession session = this.sessionFactory.OpenSession())
            {
                var emp1 = new Employee() { EmpName = "xr" };
                var emp2 = new Employee() { EmpName = "wxr" };
                var department = new Department() { DepName = "QQ" };
                //以下两句为A组合 Employee对象来维护关系
                //emp1.Department = department;
                //emp2.Department = department;
                //以下两句为B组合 Department对象来维护关系
                department.Employees.Add(emp1);
                department.Employees.Add(emp2);
                ITransaction transaction = session.BeginTransaction();
                try
                {
                    session.Save(department);
                    session.Save(emp1);
                    session.Save(emp2);
                    transaction.Commit();
                }
                catch (Exception ex)
                {
                    transaction.Rollback();
                    throw ex;
                }
            }
        }

测试结果

代码中维持关系的是Department对象或者说是Department对象下的Employee属性

生成了5条语句 (三条insert语句然后在把后来插入的两条insertEmp给update) [暂且不考虑效率]

上面2个测试的例子说明两端都为false的情况下随意一端来维持关系都是可以的。

但是用department对象来关联要生成5条语句效率不敢恭维，而且department.employees.add 在lazy="true"的时候也很吓人（上面有提到过）

结论1：尽量不要用department对象也就是带有集合属性的一端去维持关系。

one端为false,many端为true

one端

many端

<many-to-one name="Department" class="Department" column="DepId" lazy="proxy"></many-to-one>

大家知道many端默认为inverse="false"，怎么才能模拟出inverse="true".

<many-to-one name="Department" class="Department" column="DepId" insert="false" update="false" lazy="proxy"></many-to-one>

<many-to-one/>和<one-to-one/>没有inverse属性，可以用insert和update属性模拟出inverse="true"，

加上insert="false" ，update="false" 两个默认都为true。

这样就模拟出了inverse="true"了

就是说 many端不参与关系维护，而one端参与关系维护

测试代码利用A组合

[Test]
        public void SaveDepartment()
        {
            using (ISession session = this.sessionFactory.OpenSession())
            {
                var emp1 = new Employee() { EmpName = "xr" };
                var emp2 = new Employee() { EmpName = "wxr" };
                var department = new Department() { DepName = "QQ" };
                //以下两句为A组合 Employee对象来维护关系
                emp1.Department = department;
                emp2.Department = department;
                //以下两句为B组合 Department对象来维护关系
                //department.Employees.Add(emp1);
                //department.Employees.Add(emp2);
                ITransaction transaction = session.BeginTransaction();
                try
                {
                    session.Save(department);
                    session.Save(emp1);
                    session.Save(emp2);
                    transaction.Commit();
                }
                catch (Exception ex)
                {
                    transaction.Rollback();
                    throw ex;
                }
            }
        }

测试结果

细心的同学会发现这里的2 3条insert语句它们的Department外键并没有插入

说明他们的关系没有维护成功。

在来A组合换成B组合

[Test]
        public void SaveDepartment()
        {
            using (ISession session = this.sessionFactory.OpenSession())
            {
                var emp1 = new Employee() { EmpName = "xr" };
                var emp2 = new Employee() { EmpName = "wxr" };
                var department = new Department() { DepName = "QQ" };
                //以下两句为A组合 Employee对象来维护关系
                //emp1.Department = department;
                //emp2.Department = department;
                //以下两句为B组合 Department对象来维护关系
                department.Employees.Add(emp1);
                department.Employees.Add(emp2);
                ITransaction transaction = session.BeginTransaction();
                try
                {
                    session.Save(department);
                    session.Save(emp1);
                    session.Save(emp2);
                    transaction.Commit();
                }
                catch (Exception ex)
                {
                    transaction.Rollback();
                    throw ex;
                }
            }
        }

测试结果

同样生成了5条SQL 与上面两端为 false的B组测试情况一样

也就验证了上面的话

就是说 many（Employee）端不参与关系维护，而one（Department）端参与关系维护

one端为true,many端为false

这个不用测了吧？跟开篇的例子一样的。如果有兴趣的同学们可以自己测试一下另一种情况。

到底在哪端设置inverse呢？

大部分我们都在没有集合的那一端设置inverse="false"，如果用集合那端来维持关系。比如department.employees.add(上面提到过 lazy="true")

怎么去记这个东西。其实我也被这个东西困扰了20多个小时了。

总结一下：

对于双向one-to-many或者many-to-one
inverse="true"被指定于集合端（one-to-many/many-to-many），很少被指定于引用端（many-to-one/one-to-one/any）(默认为inverse="false")。

如果集合端为<list>或<map>，并且子表中的index或key字段没有被作为普通属性映射，则必须让集合有效而在引用端使用inverse，其余一切情况，均强烈建议在集合上使用inverse

对于两端都是集合的双向many-to-many
有一端的集合可以任意地使用<set>, <bag>, <idbag>, <list>, <map>元素，而另外一段的集合则只能使用<set>或<bag>
如果有一段是<idbag>, <list>或<map>，则inverse属性必须加载另外一端的<set>或<bag>上
如果两端都为<set>或<bag>，则任意。但出于优化目的，尽量加在概率上长度比较大的集合端上

（比如，一个用户的角色可能只有几种，但是一种角色可能被授予很多用户，请在Role对象的Users集合上添加inverse="true"）

全文完。希望看完的同学能够掌握inverse这个怪物.

本文链接

【翻译】从头开始编写一个Orchard网上商店模块(1) - 介绍

Wed, 15 Feb 2012 00:17:00 +0800

原文地址：http://skywalkersoftwaredevelopment.net/blog/writing-an-orchard-webshop-module-from-scratch-part-1

介绍
在这个系列博客中，我们将共同经历从头开始构建一个Orchard模块的过程！
虽然Orchard是一个了不起CMS（内容管理系统），有着强大的功能和令人振奋的架构，可以无限的扩展，但它可能需要花费一定时间，以充分了解它的架构，并能够定制您自己的主题的各个方面或甚至创造整个模块来集成Orchard所有的可扩展性点。

我希望，你将受益于我前进的道路上所获得的知识，你会看到Orchard及其架构之美。它不仅只是在简单或高级的网站和博客方面表现很出色，同时它也是一个非常基础的平台，用于创建各种基于Web的应用，如电子商务后端, CRM的投票系统，项目管理，社区网站，学习管理系统等等。基本上你打算从头创建的任何应用都应考虑使用Orchard创建。Orchard实际上是一个可扩展的框架，它不仅仅“只是”一个CMS。你可以通过插件方式做任何常规ASP.NET MVC应用可以做的事，同时Orchard还拥有一套丰富的功能和兼容概念，你可以获得额外的好处。

本播客系列主要面向刚刚接触Orchard的ASP.NET MVC开发人员，在开始深入这前，如果您还没有阅读过下面文章，我强烈建议您先阅读以下文章：
http://docs.orchardproject.net/Documentation/How-Orchard-works
http://msdn.microsoft.com/en-us/magazine/hh708754.aspx

网上商店功能

我们的网上商店模块将启用以下功能：

管理员将能够将任意ContentType(内容类型)通过附加到ProductPart上，从而把它变成产品。
网站访客（顾客）将能够把产品添加到购物篮，通过网站注册，并成为注册用户。
用户将能够进行结算和通过在线支付服务提供商（PSP）支付（在我们的演示，我们将使用Ogone模拟PSP）选定的产品。
在客户被重定向到PSP之前，系统将创建一个Order(订单)记录，及其OrderDetail (订单明细)记录。
在客户支付订单后，我们需要处理的产品交付。在实物产品的情况下，我们可能要通知一些航运伙伴。在虚拟产品的情况下，我们可能要产生类似于票据，或其他近似的产品。为了这种灵活性，我们将实现某种接口IShippingProvider，我们将创建两个简单的实现：一个是发送电子邮件通知托运人，另一个会产生票据。
管理后台，使管理员能够管理客户以及订单。

（注意: 关于嵌入截图, 出现一些截图太小，你只需拖动图片到您的浏览器的地址栏中，查看其原始大小的图片。）

好吧，就让我们开始创建Orchard Webshop Module(网店模块)！

第1部分 - 简介（本篇）
第2部分 - 配置您的Orchard开发环境
 第3部分 - 创建Orchard.Webshop模块项目
第4部分 - 创建ProductPart
第5部分 - 创建和渲染ProductCatalog的内容类型
第6部分 - 创建购物车服务和控制器
第7部分 - 渲染ShoppingCart和ShoppingCartWidget
第8部分 - 注册新客户与网站
第9部分 - 创建订单和与PSP通信
第10部分 - 客户和订单管理后端
第11部分 - 在内容列表中定制产品和类别的：DisplayTypes
第12部分 - 与ERP系统集成
第13部分 - 处理运费和税费
第14部分 - 实施付款方式：Google Checkout
第15部分 - 实施付款方式：PayPal

点击这里查看演示！

本文链接

Ubuntu下 FileZilla安装历险记

Wed, 15 Feb 2012 00:09:00 +0800

以前在学校的时候经常使用FileZilla 下载资源，觉得挺好的；但是工作以后再也没有用过；最近需要做了一些网页想上传到网站中，于是下载了FileZilla_3.5.3_src.tar.bz2 源码，然后进行编译：提示没有wxWidgets 所以又接着下载 wxWidgets , 于是从 http://www.wxwidgets.org/ 下载了最新版 wxWidgets-2.9.3.tar.bz2 ，解压安装，安装完成之后；再来编译FileZilla.

不料又提示： configure: error: idna.h not found which is part of GNU libidn.

晕菜了............

只能打开 configure 看看这个Shell脚本：其中有这么一段：

# Libidn checks
  # -------------

  ac_fn_c_check_header_mongrel "$LINENO" "idna.h" "ac_cv_header_idna_h" "$ac_includes_default"
if test "x$ac_cv_header_idna_h" = xyes; then :

else

    as_fn_error $? "idna.h not found which is part of GNU libidn." "$LINENO" 5

fi

checking for wxWidgets version >= 2.8.12 (--unicode=yes --universal=no)... yes (version 2.9.3)
checking for wxWidgets static library... no
configure: error: You need to use wxWidgets 2.8.x to compile this program.

这提示 Libidn 库没有安装，那么安装吧：

sudo apt-get install  libidn*

想想这下应该OK了吧》

始料未及的是提示

checking for wxWidgets version >= 2.8.12 (--unicode=yes --universal=no)... yes (version 2.9.3)
checking for wxWidgets static library... no
configure: error: You need to use wxWidgets 2.8.x to compile this program.

我晕，我的版本可是 2.9.3耶，远高于2.8.x ; 那只能修改 Shell脚本了： configure

if test "$wx_config_major_version" -gt "2" || test "$wx_config_minor_version" -gt "8"; then
    as_fn_error $? "You need to use wxWidgets 2.8.x to compile this program." "$LINENO" 5
  fi

原来版本还不能高于2.8 将 8 改成9；然后将以下2.8 全部改成 2.9.*就 OK了。

if test -n "$LIBGNUTLS_CFLAGS"; then
    pkg_cv_LIBGNUTLS_CFLAGS="$LIBGNUTLS_CFLAGS"
 elif test -n "$PKG_CONFIG"; then
    if test -n "$PKG_CONFIG" && \
    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"gnutls >= 2.8.3\""; } >&5
  ($PKG_CONFIG --exists --print-errors "gnutls >= 2.8.3") 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; }; then
  pkg_cv_LIBGNUTLS_CFLAGS=`$PKG_CONFIG --cflags "gnutls >= 2.8.3" 2>/dev/null`
else
  pkg_failed=yes
fi
 else
    pkg_failed=untried
fi
if test -n "$LIBGNUTLS_LIBS"; then
    pkg_cv_LIBGNUTLS_LIBS="$LIBGNUTLS_LIBS"
 elif test -n "$PKG_CONFIG"; then
    if test -n "$PKG_CONFIG" && \
    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"gnutls >= 2.8.3\""; } >&5
  ($PKG_CONFIG --exists --print-errors "gnutls >= 2.8.3") 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; }; then
  pkg_cv_LIBGNUTLS_LIBS=`$PKG_CONFIG --libs "gnutls >= 2.8.3" 2>/dev/null`
else
  pkg_failed=yes
fi
 else
    pkg_failed=untried
fi

总结：在安装一个软件之前一定要看相关文档： INSTALL， README 等；里面会提供软件依赖情况，如FileZilla 的 INSTALL 的 Requirements：

8 FileZilla depends on the following libraries:
  9 - wxWidgets 2.8.12 or greater
 10 - libidn
 11 - GnuTLS 2.8.3 or greater
 12 - libdbus on *nix
 13 - sqlite3 3.7 or greater

在编译或使用的过程中得查看 configure 文件。如果还是搞不定，那就GOOGLE吧。

本文链接

ASP.NET jQuery 食谱23 (jQuery AJAX实现调用页面后台方法和web服务定义的方法)

Wed, 15 Feb 2012 00:09:00 +0800

这节我们来看下如何实现AJAX调用页面后台方法和web服务定义的方法，下面通过验证用户的例子，先讲解如何调用页面后台方法，具体实现步骤如下：

1.新建Recipe23.aspx页面。

2.在该页面的后台文件Recipe23.aspx.cs中添加引用

using System.Web.Services;

3.定义静态数组和初始化数据

public static string[] userNameArrray;

    protected void Page_Load(object sender, EventArgs e)
    {
        userNameArrray = new string[5] { "KenLee01", "KenLee02", "KenLee03", "KenLee04", "KenLee05" };
    }

4.定义验证用户名合法性的静态方法

/// <summary>
    /// 验证用户是否合法
    /// </summary>
    /// <remarks>
    /// AJAX如果要直接调用该方法，需要添加[WebMethod()]，并定义为静态方法
    /// </remarks>
    /// <param name="sUserName">用户名</param>
    /// <returns>返回结果</returns>
    [WebMethod()]
    public static bool CheckUserName(string sUserName)
    {
        // 如果用户存在，就验证合法
        if (userNameArrray.Contains(sUserName))
        {
            return true;
        }

        return false;
    }

5.在Recipe.aspx里面实现界面结构代码如下

<form id="form1" runat="server">
    <div>
        <asp:TextBox ID="txtUserName" runat="server"></asp:TextBox>
        <asp:Button ID="btnCheck" runat="server" Text="验证用户" />
    </div>
    </form>

6.在Recipe.aspx里面实现AJAX调用页面后台用户验证方法CheckUserName的脚本代码如下

<script type="text/javascript">
        $(function () {
            $("#btnCheck").click(function (e) {
                e.preventDefault();

                // 首先判断用户名是否为空，并给出提示
                if ($("#txtUserName").val() == "") {
                    alert("请输入用户名！");
                }
                else {
                    sendData($("#txtUserName").val());
                }
            });

            // 定义一个AJAX请求方法
            function sendData(sUserName) {
                // 访问页面后台方法
                var loc = window.location.href;
                $.ajax({
                    type: "POST",
                    url: loc + "/CheckUserName",
                    // sUserName要跟请求方法CheckUserName定义的参数名称要保持一致
                    // json数据格式是由一对键值构成，如{"name1":"value1", "name2":"value2"}
                    data: '{ "sUserName": "' + sUserName + '"}',
                    // 发送信息至服务器时内容编码类型
                    contentType: "application/json; charset=utf-8",
                    dataType: "json",
                    success: function (msg) {
                        // AJAX响应被包装到一个d对象里，如{"d":true}, 
                        // 因此需要用到msg.d来获取请求返回的布尔值
                        if (msg.d) {
                            alert("验证用户成功！");
                        }
                        else {
                            alert("验证用户失败！");
                        }
                    },
                    error: function (xhr, textStatus, errorThrown) {
                        alert("AJAX错误：" + errorThrown);
                    }
                });
            }
        });
    </script>

7.运行程序后显示页面如下：

8.输入用户名KenLee10:

9.输入用户名KenLee01:

10.还可以通过Firebug观察AJAX请求响应的数据，请求数据如下：

11.请求响应的JSON数据：

下面再来看下AJAX如何调用Web服务：

1.创建Web服务用户验证的文件UserNameWS.asmx，必须添加[System.Web.Script.Services.ScriptService]，实现用户验证代码如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Services;

/// <summary>
///UserNameWS 的摘要说明
/// </summary>
[WebService(Namespace = "http://tempuri.org/")]
[WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
//若要允许使用 ASP.NET AJAX 从脚本中调用此 Web 服务，请取消对下行的注释。 
[System.Web.Script.Services.ScriptService]
public class UserNameWS : System.Web.Services.WebService {

    public UserNameWS () {

        //如果使用设计的组件，请取消注释以下行 
        //InitializeComponent(); 
    }

    /// <summary>
    /// 验证用户是否合法
    /// </summary>
    /// <remarks>
    /// AJAX如果要直接调用该方法，需要添加[WebMethod()]，并定义为静态方法
    /// </remarks>
    /// <param name="sUserName">用户名</param>
    /// <returns>返回结果</returns>
    [WebMethod]
    public bool CheckUserName(string sUserName)
    {
        string[] userNameArrray = new string[5] { "KenLee01", "KenLee02", "KenLee03", "KenLee04", "KenLee05" };
        // 如果用户存在，就验证合法
        if (userNameArrray.Contains(sUserName))
        {
            return true;
        }

        return false;
    }
}

2.修改Recipe23.aspx的脚本代码sendData函数,只需修改loc访问地址：

// 定义一个AJAX请求方法
function sendData(sUserName) {
  // 访问页面后台方法
  // var loc = window.location.href;
  // 访问Web服务
  var loc = "UserNameWS.asmx";
........

简单完成上面两步，就可以直接调用web服务里面定义的方法了。具体显示的效果图，和上面介绍的AJAX访问页面方法的效果图是一样的，这里就不用重复写了。

本文链接

【面试】——不能搞混这些概念

Tue, 14 Feb 2012 23:56:00 +0800

类、结构、构造函数、抽象类这么多的概念一点一点的加++

1、定义一个类

public class Person
    {
        private string _name;
        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }
        private int _age;
        public int Age
        {
            get { return _age; }
            set { _age = value; }
        }
        public virtual void SayHi()
        {
            Console.WriteLine("Hi~~~");
        }
    }

①类前面和类内部，可以用修饰符private，public，internal，protected来修饰，限制方位域范围。如果类的成员不写访问修饰符则默认为private。如果类前面不写访问修饰符默认为internal。

②类，内部可以定义属性，方法亦可设置虚方法，或将方法重载。

③类，可以继承，但是是单继承。

④类成员在使用前必须赋初值。

2、接口

public interface ICanFly
{
   void Fly();
}

①接口可以多继承，前面可以用public,internal,protected，来修饰，在不写任何修饰符的时候，默认为internal。当然你也可以写成private来修饰，但是这显然没有什么意义，其他程序集都不能访问。

②接口内可以写方法，事件、属性、索引器、静态方法、静态字段、静态构造函数以及常数。但是注意：C#中不能包含任何静态成员。

③接口内部设置的方法Fly，不能有实现；前面不能有修饰符。

3、构造函数

public Person(string name,int age,string gender)
{
  this.name=name;
  this.age=age;
  this.gender=gender;
}

①方法名称和类名必须保持一致。

②方法没有返回值。连void也不能有。方法的访问修饰符默认为public

③构造函数也可以方法重载。

4、结构

struct Person
    {
        private string _name;

        public string Name1
        {
            get { return _name; }
            set { _name = value; }
        }
        private void SayHi()
        {
            Console.WriteLine("Hello...");
        }

    }

结构和类一同别：

相同点：语法类似。

不同点：

①class是引用类型，继承自system.object，而struct是值类型，继承自system.valuetype。不具有多态性。注意system.valuetype是引用类型。

②class支持继承，而struct没有继承性。

③数据量比较小，的时候使用结构

④结构可以实现接口，但结构不能继承（可以通过反编译查看，int32类型，可以看到实现了很多接口）

5、抽象类

public abstract class Person
{
   public string Name
   {
      get;
      set;
   }
   public int Age
   {
      get;
      set;
   }
   public string Email
   {
      get;
      set;
   }
   public sbstract void SayHi();
}

①抽象类不能实例化，类继承此抽象类必须实现方法。

②当用抽象关键字标记方法有关键字，abstract标记方法的时候，方法不能有任何方法体

③如果这个类中有一个成语为抽象的，则整个类也是抽象的。

本文链接