lyfz_repos/其他源码/HPSocketCS/Sdk.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.InteropServices;
using HPSocketCS;
using System.IO;
using System.Security.Cryptography;


namespace HPSocketCS
{

    

    /// <summary>
    /// 通信组件服务状态,用程序可以通过通信组件的 GetState() 方法获取组件当前服务状态
    /// </summary>
    public enum ServiceState
    {
        /// <summary>
        /// 正在启动
        /// </summary>
        Starting = 0,
        /// <summary>
        /// 已经启动
        /// </summary>
        Started = 1,
        /// <summary>
        /// 正在停止
        /// </summary>
        Stoping = 2,
        /// <summary>
        /// 已经停止
        /// </summary>
        Stoped = 3,
    }

    /// <summary>
    /// Socket 操作类型,应用程序的 OnErrror() 事件中通过该参数标识是哪种操作导致的错误
    /// </summary>
    public enum SocketOperation
    {
        Unknown = 0,    // Unknown
        Acccept = 1,    // Acccept
        Connnect = 2,   // Connnect
        Send = 3,       // Send
        Receive = 4,    // Receive
        Close = 5,    // Receive
    };

    /// <summary>
    /// 事件通知处理结果,事件通知的返回值，不同的返回值会影响通信组件的后续行为
    /// </summary>
    public enum HandleResult
    {
        /// <summary>
        /// 成功
        /// </summary>
        Ok = 0,
        /// <summary>
        /// 忽略
        /// </summary>
        Ignore = 1,
        /// <summary>
        /// 错误
        /// </summary>
        Error = 2,
    };


    /// <summary>
    /// 名称：操作结果代码
    /// 描述：组件 Start() / Stop() 方法执行失败时，可通过 GetLastError() 获取错误代码
    /// </summary>
    public enum SocketError
    {
        /// <summary>
        /// 成功
        /// </summary>
        Ok = 0,
        /// <summary>
        /// 当前状态不允许操作
        /// </summary>
        IllegalState = 1,
        /// <summary>
        /// 非法参数
        /// </summary>
        InvalidParam = 2,
        /// <summary>
        /// 创建 SOCKET 失败
        /// </summary>
        SocketCreate = 3,
        /// <summary>
        /// 绑定 SOCKET 失败
        /// </summary>
        SocketBind = 4,
        /// <summary>
        /// 设置 SOCKET 失败
        /// </summary>
        SocketPrepare = 5,
        /// <summary>
        /// 监听 SOCKET 失败
        /// </summary>
        SocketListen = 6,
        /// <summary>
        /// 创建完成端口失败
        /// </summary>
        CPCreate = 7,
        /// <summary>
        /// 创建工作线程失败
        /// </summary>
        WorkerThreadCreate = 8,
        /// <summary>
        /// 创建监测线程失败
        /// </summary>
        DetectThreadCreate = 9,
        /// <summary>
        /// 绑定完成端口失败
        /// </summary>
        SocketAttachToCP = 10,
        /// <summary>
        /// 连接服务器失败
        /// </summary>
        ConnectServer = 11,
        /// <summary>
        /// 网络错误
        /// </summary>
        Network = 12,
        /// <summary>
        /// 数据处理错误
        /// </summary>
        DataProc = 13,
        /// <summary>
        /// 数据发送失败
        /// </summary>
        DataSend = 14,

        /***** SSL Socket 扩展操作结果代码 *****/
        /// <summary>
        /// SSL 环境未就绪
        /// </summary>
        SSLEnvNotReady = 101,
    };

    /// <summary>
    /// 数据抓取结果,数据抓取操作的返回值
    /// </summary>
    public enum FetchResult
    {
        /// <summary>
        /// 成功
        /// </summary>
        Ok = 0,
        /// <summary>
        /// 抓取长度过大
        /// </summary>
        LengthTooLong = 1,
        /// <summary>
        /// 找不到 ConnID 对应的数据
        /// </summary>
        DataNotFound = 2,
    };

    /// <summary>
    /// 发送策略
    /// </summary>
    public enum SendPolicy
    {
        /// <summary>
        /// 打包模式（默认）
        /// </summary>
        Pack = 0,
        /// <summary>
        /// 安全模式
        /// </summary>
        Safe = 1,
        /// <summary>
        /// 直接模式
        /// </summary>
        Direct = 2,
    };

    /// <summary>
    /// 播送模式  UDP 组件的播送模式（组播或广播）
    /// </summary>
    public enum CastMode
    {
        /// <summary>
        /// 组播
        /// </summary>
        Multicast = 0,
        /// <summary>
        /// 广播
        /// </summary>
        Broadcast = 1,

    }

    /****************************************************/
    /************** sockaddr结构体,udp服务器时OnAccept最后个参数可转化 **************/
    [StructLayout(LayoutKind.Sequential)]
    public struct in_addr
    {
        public ulong S_addr;
    }

    //[StructLayout(LayoutKind.Sequential)]
    //public struct in_addr
    //{
    //    public byte s_b1, s_b2, s_b3, s_b4;
    //}

    [StructLayout(LayoutKind.Sequential)]
    public struct sockaddr_in
    {
        public short sin_family;
        public ushort sin_port;
        public in_addr sin_addr;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)]
        public byte[] sLibNamesin_zero;
    }

    /****************************************************/

    [StructLayout(LayoutKind.Sequential)]
    public struct WSABUF
    {
        public int Length;
        public IntPtr Buffer;
    }
}


namespace HPSocketCS
{
    /// <summary>
    /// Unicode版本
    /// </summary>
    public class Sdk
    {
        /// <summary>
        /// 网络数据包缓存大小 (16MB)
        /// </summary>
       public  const int PacketBufferSize=8*1024*1024;
       /// <summary>
       /// 文件MD5验证大小
       /// </summary>
       public const long FileMD5VerifySize = 96 * 1024 * 1024;
        /*****************************************************************************************************/
        /******************************************** 公共类、接口 ********************************************/
        /*****************************************************************************************************/



        /****************************************************/
        /************** HPSocket4C.dll 回调函数 **************/
        /* Agent & Server & Clent */
        public delegate HandleResult OnSend(IntPtr connId, IntPtr pData, int length);
        public delegate HandleResult OnReceive(IntPtr connId, IntPtr pData, int length);
        public delegate HandleResult OnPullReceive(IntPtr connId, int length);
        public delegate HandleResult OnClose(IntPtr connId, SocketOperation enOperation, int errorCode);

        /* Agent & Server */
        public delegate HandleResult OnShutdown();

        /* Agent & Client */
        public delegate HandleResult OnPrepareConnect(IntPtr connId /* IntPtr pClient */, uint socket);
        public delegate HandleResult OnConnect(IntPtr connId /* IntPtr pClient */);

        /* Server */
        public delegate HandleResult OnPrepareListen(IntPtr soListen);
        public delegate HandleResult OnAccept(IntPtr connId, IntPtr pClient);

        /* SSL */
        public delegate HandleResult OnHandShake(IntPtr connId);

        /****************************************************/
        /************** HPSocket4C.dll 导出函数 **************/

        /// <summary>
        /// 创建 TcpServer 对象
        /// </summary>
        /// <param name="pListener"></param>
        /// <returns></returns>
        public static IntPtr Create_HP_TcpServer(IntPtr pListener)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.Create_HP_TcpServer(pListener);
            }
            else
            {
                return Sdk_x86.Create_HP_TcpServer(pListener);
            }
        }

        /// <summary>
        /// 创建 TcpClient 对象
        /// </summary>
        /// <param name="pListener"></param>
        /// <returns></returns>
        public static IntPtr Create_HP_TcpClient(IntPtr pListener)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.Create_HP_TcpClient(pListener);
            }
            else
            {
                return Sdk_x86.Create_HP_TcpClient(pListener);
            }
        }
        /// <summary>
        /// 创建 TcpAgent 对象
        /// </summary>
        /// <param name="pListener"></param>
        /// <returns></returns>
        public static IntPtr Create_HP_TcpAgent(IntPtr pListener)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.Create_HP_TcpAgent(pListener);
            }
            else
            {
                return Sdk_x86.Create_HP_TcpAgent(pListener);
            }
        }

        /// <summary>
        /// 创建 TcpPullServer 对象
        /// </summary>
        /// <param name="pListener"></param>
        /// <returns></returns>
        public static IntPtr Create_HP_TcpPullServer(IntPtr pListener)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.Create_HP_TcpPullServer(pListener);
            }
            else
            {
                return Sdk_x86.Create_HP_TcpPullServer(pListener);
            }
        }
        /// <summary>
        /// 创建 TcpPullClient 对象
        /// </summary>
        /// <param name="pListener"></param>
        /// <returns></returns>
        public static IntPtr Create_HP_TcpPullClient(IntPtr pListener)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.Create_HP_TcpPullClient(pListener);
            }
            else
            {
                return Sdk_x86.Create_HP_TcpPullClient(pListener);
            }
        }
        /// <summary>
        /// 创建 TcpPullAgent 对象
        /// </summary>
        /// <param name="pListener"></param>
        /// <returns></returns>
        public static IntPtr Create_HP_TcpPullAgent(IntPtr pListener)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.Create_HP_TcpPullAgent(pListener);
            }
            else
            {
                return Sdk_x86.Create_HP_TcpPullAgent(pListener);
            }
        }
        /// <summary>
        /// 创建 HP_TcpPackServer 对象
        /// </summary>
        /// <param name="pListener"></param>
        /// <returns></returns>
        public static IntPtr Create_HP_TcpPackServer(IntPtr pListener)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.Create_HP_TcpPackServer(pListener);
            }
            else
            {
                return Sdk_x86.Create_HP_TcpPackServer(pListener);
            }
        }
        /// <summary>
        /// 创建 HP_TcpPackAgent 对象
        /// </summary>
        /// <param name="pListener"></param>
        /// <returns></returns>
        public static IntPtr Create_HP_TcpPackAgent(IntPtr pListener)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.Create_HP_TcpPackAgent(pListener);
            }
            else
            {
                return Sdk_x86.Create_HP_TcpPackAgent(pListener);
            }
        }
        /// <summary>
        /// 创建 HP_TcpPackAgent 对象
        /// </summary>
        /// <param name="pListener"></param>
        /// <returns></returns>
        public static IntPtr Create_HP_TcpPackClient(IntPtr pListener)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.Create_HP_TcpPackClient(pListener);
            }
            else
            {
                return Sdk_x86.Create_HP_TcpPackClient(pListener);
            }
        }
        /// <summary>
        /// 创建 UdpServer 对象
        /// </summary>
        /// <param name="pListener"></param>
        /// <returns></returns>
        public static IntPtr Create_HP_UdpServer(IntPtr pListener)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.Create_HP_UdpServer(pListener);
            }
            else
            {
                return Sdk_x86.Create_HP_UdpServer(pListener);
            }
        }
        /// <summary>
        /// 创建 UdpClient 对象
        /// </summary>
        /// <param name="pListener"></param>
        /// <returns></returns>
        public static IntPtr Create_HP_UdpClient(IntPtr pListener)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.Create_HP_UdpClient(pListener);
            }
            else
            {
                return Sdk_x86.Create_HP_UdpClient(pListener);
            }
        }


        /// <summary>
        /// 销毁 TcpServer 对象
        /// </summary>
        /// <param name="pServer"></param>
        /// <returns></returns>

        public static void Destroy_HP_TcpServer(IntPtr pServer)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.Destroy_HP_TcpServer(pServer);
            }
            else
            {
                Sdk_x86.Destroy_HP_TcpServer(pServer);
            }
        }

        /// <summary>
        /// 销毁 TcpClient 对象
        /// </summary>
        /// <param name="pClient"></param>
        /// <returns></returns>

        public static void Destroy_HP_TcpClient(IntPtr pClient)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.Destroy_HP_TcpClient(pClient);
            }
            else
            {
                Sdk_x86.Destroy_HP_TcpClient(pClient);
            }
        }

        /// <summary>
        /// 销毁 TcpAgent 对象
        /// </summary>
        /// <param name="pAgent"></param>
        /// <returns></returns>

        public static void Destroy_HP_TcpAgent(IntPtr pAgent)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.Destroy_HP_TcpAgent(pAgent);
            }
            else
            {
                Sdk_x86.Destroy_HP_TcpAgent(pAgent);
            }
        }
        /// <summary>
        /// 销毁 TcpPullServer 对象
        /// </summary>
        /// <param name="pClient"></param>
        /// <returns></returns>

        public static void Destroy_HP_TcpPullServer(IntPtr pServer)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.Destroy_HP_TcpPullServer(pServer);
            }
            else
            {
                Sdk_x86.Destroy_HP_TcpPullServer(pServer);
            }
        }

        /// <summary>
        /// 销毁 TcpPullClient 对象
        /// </summary>
        /// <param name="pClient"></param>
        /// <returns></returns>

        public static void Destroy_HP_TcpPullClient(IntPtr pClient)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.Destroy_HP_TcpPullClient(pClient);
            }
            else
            {
                Sdk_x86.Destroy_HP_TcpPullClient(pClient);
            }
        }

        /// <summary>
        /// 销毁 TcpPullAgent 对象
        /// </summary>
        /// <param name="pAgent"></param>
        /// <returns></returns>

        public static void Destroy_HP_TcpPullAgent(IntPtr pAgent)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.Destroy_HP_TcpPullAgent(pAgent);
            }
            else
            {
                Sdk_x86.Destroy_HP_TcpPullAgent(pAgent);
            }
        }

        /// <summary>
        /// 销毁 HP_TcpPackServer 对象
        /// </summary>
        /// <param name="pServer"></param>

        public static void Destroy_HP_TcpPackServer(IntPtr pServer)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.Destroy_HP_TcpPackServer(pServer);
            }
            else
            {
                Sdk_x86.Destroy_HP_TcpPackServer(pServer);
            }
        }

        /// <summary>
        /// 销毁 HP_TcpPackAgent 对象
        /// </summary>
        /// <param name="pAgent"></param>

        public static void Destroy_HP_TcpPackAgent(IntPtr pAgent)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.Destroy_HP_TcpPackAgent(pAgent);
            }
            else
            {
                Sdk_x86.Destroy_HP_TcpPackAgent(pAgent);
            }
        }

        /// <summary>
        /// 销毁 HP_TcpPackClient 对象
        /// </summary>
        /// <param name="pClient"></param>

        public static void Destroy_HP_TcpPackClient(IntPtr pClient)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.Destroy_HP_TcpPackClient(pClient);
            }
            else
            {
                Sdk_x86.Destroy_HP_TcpPackClient(pClient);
            }
        }


        /// <summary>
        /// 销毁 UdpServer 对象
        /// </summary>
        /// <param name="pServer"></param>
        /// <returns></returns>

        public static void Destroy_HP_UdpServer(IntPtr pServer)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.Destroy_HP_UdpServer(pServer);
            }
            else
            {
                Sdk_x86.Destroy_HP_UdpServer(pServer);
            }
        }

        /// <summary>
        /// 销毁 UdpClient 对象
        /// </summary>
        /// <param name="pClient"></param>
        /// <returns></returns>

        public static void Destroy_HP_UdpClient(IntPtr pClient)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.Destroy_HP_UdpClient(pClient);
            }
            else
            {
                Sdk_x86.Destroy_HP_UdpClient(pClient);
            }
        }


        /// <summary>
        /// 创建 TcpServerListener 对象
        /// </summary>
        /// <returns></returns>

        public static IntPtr Create_HP_TcpServerListener()
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.Create_HP_TcpServerListener();
            }
            else
            {
                return Sdk_x86.Create_HP_TcpServerListener();
            }
        }

        /// <summary>
        /// 创建 TcpClientListener 对象
        /// </summary>
        /// <returns></returns>

        public static IntPtr Create_HP_TcpClientListener()
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.Create_HP_TcpClientListener();
            }
            else
            {
                return Sdk_x86.Create_HP_TcpClientListener();
            }
        }
        /// <summary>
        /// 创建 TcpAgentListener 对象
        /// </summary>
        /// <returns></returns>

        public static IntPtr Create_HP_TcpAgentListener()
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.Create_HP_TcpAgentListener();
            }
            else
            {
                return Sdk_x86.Create_HP_TcpAgentListener();
            }
        }

        /// <summary>
        /// 创建 TcpPullServerListener 对象
        /// </summary>
        /// <returns></returns>

        public static IntPtr Create_HP_TcpPullServerListener()
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.Create_HP_TcpPullServerListener();
            }
            else
            {
                return Sdk_x86.Create_HP_TcpPullServerListener();
            }
        }

        /// <summary>
        /// 创建 TcpPullClientListener 对象
        /// </summary>
        /// <returns></returns>

        public static IntPtr Create_HP_TcpPullClientListener()
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.Create_HP_TcpPullClientListener();
            }
            else
            {
                return Sdk_x86.Create_HP_TcpPullClientListener();
            }
        }

        /// <summary>
        /// 创建 TcpPullAgentListener 对象
        /// </summary>
        /// <returns></returns>

        public static IntPtr Create_HP_TcpPullAgentListener()
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.Create_HP_TcpPullAgentListener();
            }
            else
            {
                return Sdk_x86.Create_HP_TcpPullAgentListener();
            }
        }

        /// <summary>
        /// 创建 UdpServerListener 对象
        /// </summary>
        /// <returns></returns>

        public static IntPtr Create_HP_UdpServerListener()
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.Create_HP_UdpServerListener();
            }
            else
            {
                return Sdk_x86.Create_HP_UdpServerListener();
            }
        }

        /// <summary>
        /// 创建 UdpClientListener 对象
        /// </summary>
        /// <returns></returns>

        public static IntPtr Create_HP_UdpClientListener()
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.Create_HP_UdpClientListener();
            }
            else
            {
                return Sdk_x86.Create_HP_UdpClientListener();
            }
        }


        /// <summary>
        /// 销毁 TcpServerListener 对象
        /// </summary>
        /// <param name="pListener"></param>
        /// <returns></returns>

        public static void Destroy_HP_TcpServerListener(IntPtr pListener)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.Destroy_HP_TcpServerListener(pListener);
            }
            else
            {
                Sdk_x86.Destroy_HP_TcpServerListener(pListener);
            }
        }

        /// <summary>
        /// 销毁 TcpClientListener 对象
        /// </summary>
        /// <param name="pListener"></param>
        /// <returns></returns>

        public static void Destroy_HP_TcpClientListener(IntPtr pListener)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.Destroy_HP_TcpClientListener(pListener);
            }
            else
            {
                Sdk_x86.Destroy_HP_TcpClientListener(pListener);
            }
        }

        /// <summary>
        /// 销毁 TcpAgentListener 对象
        /// </summary>
        /// <param name="pListener"></param>
        /// <returns></returns>

        public static void Destroy_HP_TcpAgentListener(IntPtr pListener)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.Destroy_HP_TcpAgentListener(pListener);
            }
            else
            {
                Sdk_x86.Destroy_HP_TcpAgentListener(pListener);
            }
        }


        /// <summary>
        /// 销毁 TcpPullServerListener 对象
        /// </summary>
        /// <param name="pListener"></param>
        /// <returns></returns>

        public static void Destroy_HP_TcpPullServerListener(IntPtr pListener)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.Destroy_HP_TcpPullServerListener(pListener);
            }
            else
            {
                Sdk_x86.Destroy_HP_TcpPullServerListener(pListener);
            }
        }

        /// <summary>
        /// 销毁 TcpPullClientListener 对象
        /// </summary>
        /// <param name="pListener"></param>
        /// <returns></returns>

        public static void Destroy_HP_TcpPullClientListener(IntPtr pListener)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.Destroy_HP_TcpPullClientListener(pListener);
            }
            else
            {
                Sdk_x86.Destroy_HP_TcpPullClientListener(pListener);
            }
        }

        /// <summary>
        /// 销毁 TcpPullAgentListener 对象
        /// </summary>
        /// <param name="pListener"></param>
        /// <returns></returns>

        public static void Destroy_HP_TcpPullAgentListener(IntPtr pListener)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.Destroy_HP_TcpPullAgentListener(pListener);
            }
            else
            {
                Sdk_x86.Destroy_HP_TcpPullAgentListener(pListener);
            }
        }

        /// <summary>
        /// 销毁 UdpServerListener 对象
        /// </summary>
        /// <param name="pListener"></param>
        /// <returns></returns>

        public static void Destroy_HP_UdpServerListener(IntPtr pListener)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.Destroy_HP_UdpServerListener(pListener);
            }
            else
            {
                Sdk_x86.Destroy_HP_UdpServerListener(pListener);
            }
        }

        /// <summary>
        /// 销毁 UdpClientListener 对象
        /// </summary>
        /// <param name="pListener"></param>
        /// <returns></returns>

        public static void Destroy_HP_UdpClientListener(IntPtr pListener)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.Destroy_HP_UdpClientListener(pListener);
            }
            else
            {
                Sdk_x86.Destroy_HP_UdpClientListener(pListener);
            }
        }


        /**********************************************************************************/
        /***************************** Server 回调函数设置方法 *****************************/


        public static void HP_Set_FN_Server_OnPrepareListen(IntPtr pListener, OnPrepareListen fn)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_Set_FN_Server_OnPrepareListen(pListener, fn);
            }
            else
            {
                Sdk_x86.HP_Set_FN_Server_OnPrepareListen(pListener, fn);
            }
        }

        public static void HP_Set_FN_Server_OnAccept(IntPtr pListener, OnAccept fn)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_Set_FN_Server_OnAccept(pListener, fn);
            }
            else
            {
                Sdk_x86.HP_Set_FN_Server_OnAccept(pListener, fn);
            }
        }

        public static void HP_Set_FN_Server_OnHandShake(IntPtr pListener, Sdk.OnHandShake fn)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_Set_FN_Server_OnHandShake(pListener, fn);
            }
            else
            {
                Sdk_x86.HP_Set_FN_Server_OnHandShake(pListener, fn);
            }
        }
        public static void HP_Set_FN_Server_OnSend(IntPtr pListener, OnSend fn)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_Set_FN_Server_OnSend(pListener, fn);
            }
            else
            {
                Sdk_x86.HP_Set_FN_Server_OnSend(pListener, fn);
            }
        }

        public static void HP_Set_FN_Server_OnReceive(IntPtr pListener, OnReceive fn)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_Set_FN_Server_OnReceive(pListener, fn);
            }
            else
            {
                Sdk_x86.HP_Set_FN_Server_OnReceive(pListener, fn);
            }
        }

        public static void HP_Set_FN_Server_OnPullReceive(IntPtr pListener, OnPullReceive fn)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_Set_FN_Server_OnPullReceive(pListener, fn);
            }
            else
            {
                Sdk_x86.HP_Set_FN_Server_OnPullReceive(pListener, fn);
            }
        }

        public static void HP_Set_FN_Server_OnClose(IntPtr pListener, OnClose fn)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_Set_FN_Server_OnClose(pListener, fn);
            }
            else
            {
                Sdk_x86.HP_Set_FN_Server_OnClose(pListener, fn);
            }
        }

        public static void HP_Set_FN_Server_OnShutdown(IntPtr pListener, OnShutdown fn)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_Set_FN_Server_OnShutdown(pListener, fn);
            }
            else
            {
                Sdk_x86.HP_Set_FN_Server_OnShutdown(pListener, fn);
            }
        }

        /**********************************************************************************/
        /***************************** Client 回调函数设置方法 *****************************/


        public static void HP_Set_FN_Client_OnPrepareConnect(IntPtr pListener, OnPrepareConnect fn)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_Set_FN_Client_OnPrepareConnect(pListener, fn);
            }
            else
            {
                Sdk_x86.HP_Set_FN_Client_OnPrepareConnect(pListener, fn);
            }
        }

        public static void HP_Set_FN_Client_OnConnect(IntPtr pListener, OnConnect fn)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_Set_FN_Client_OnConnect(pListener, fn);
            }
            else
            {
                Sdk_x86.HP_Set_FN_Client_OnConnect(pListener, fn);
            }
        }

        public static void HP_Set_FN_Client_OnSend(IntPtr pListener, OnSend fn)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_Set_FN_Client_OnSend(pListener, fn);
            }
            else
            {
                Sdk_x86.HP_Set_FN_Client_OnSend(pListener, fn);
            }
        }

        public static void HP_Set_FN_Client_OnReceive(IntPtr pListener, OnReceive fn)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_Set_FN_Client_OnReceive(pListener, fn);
            }
            else
            {
                Sdk_x86.HP_Set_FN_Client_OnReceive(pListener, fn);
            }
        }

        public static void HP_Set_FN_Client_OnPullReceive(IntPtr pListener, OnPullReceive fn)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_Set_FN_Client_OnPullReceive(pListener, fn);
            }
            else
            {
                Sdk_x86.HP_Set_FN_Client_OnPullReceive(pListener, fn);
            }
        }

        public static void HP_Set_FN_Client_OnClose(IntPtr pListener, OnClose fn)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_Set_FN_Client_OnClose(pListener, fn);
            }
            else
            {
                Sdk_x86.HP_Set_FN_Client_OnClose(pListener, fn);
            }
        }

        /**********************************************************************************/
        /****************************** Agent 回调函数设置方法 *****************************/


        public static void HP_Set_FN_Agent_OnPrepareConnect(IntPtr pListener, OnPrepareConnect fn)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_Set_FN_Agent_OnPrepareConnect(pListener, fn);
            }
            else
            {
                Sdk_x86.HP_Set_FN_Agent_OnPrepareConnect(pListener, fn);
            }
        }

        public static void HP_Set_FN_Agent_OnConnect(IntPtr pListener, OnConnect fn)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_Set_FN_Agent_OnConnect(pListener, fn);
            }
            else
            {
                Sdk_x86.HP_Set_FN_Agent_OnConnect(pListener, fn);
            }
        }

        public static void HP_Set_FN_Agent_OnSend(IntPtr pListener, OnSend fn)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_Set_FN_Agent_OnSend(pListener, fn);
            }
            else
            {
                Sdk_x86.HP_Set_FN_Agent_OnSend(pListener, fn);
            }
        }

        public static void HP_Set_FN_Agent_OnReceive(IntPtr pListener, OnReceive fn)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_Set_FN_Agent_OnReceive(pListener, fn);
            }
            else
            {
                Sdk_x86.HP_Set_FN_Agent_OnReceive(pListener, fn);
            }
        }

        public static void HP_Set_FN_Agent_OnPullReceive(IntPtr pListener, OnPullReceive fn)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_Set_FN_Agent_OnPullReceive(pListener, fn);
            }
            else
            {
                Sdk_x86.HP_Set_FN_Agent_OnPullReceive(pListener, fn);
            }
        }

        public static void HP_Set_FN_Agent_OnClose(IntPtr pListener, OnClose fn)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_Set_FN_Agent_OnClose(pListener, fn);
            }
            else
            {
                Sdk_x86.HP_Set_FN_Agent_OnClose(pListener, fn);
            }
        }

        public static void HP_Set_FN_Agent_OnShutdown(IntPtr pListener, OnShutdown fn)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_Set_FN_Agent_OnShutdown(pListener, fn);
            }
            else
            {
                Sdk_x86.HP_Set_FN_Agent_OnShutdown(pListener, fn);
            }
        }

        /**************************************************************************/
        /***************************** Server 操作方法 *****************************/

        /// <summary>
        /// 名称：启动通信组件
        /// 描述：启动服务端通信组件，启动完成后可开始接收客户端连接并收发数据
        /// </summary>
        /// <param name="pServer"></param>
        /// <param name="pszBindAddress">监听地址</param>
        /// <param name="usPort">监听端口</param>
        /// <returns>失败，可通过 GetLastError() 获取错误代码</returns>
        public static bool HP_Server_Start(IntPtr pServer, String pszBindAddress, ushort usPort)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Server_Start(pServer, pszBindAddress, usPort);
            }
            else
            {
                return Sdk_x86.HP_Server_Start(pServer, pszBindAddress, usPort);
            }
        }

        /// <summary>
        /// 关闭服务端通信组件，关闭完成后断开所有客户端连接并释放所有资源
        /// </summary>
        /// <param name="pServer"></param>
        /// <returns>失败，可通过 GetLastError() 获取错误代码</returns>

        public static bool HP_Server_Stop(IntPtr pServer)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Server_Stop(pServer);
            }
            else
            {
                return Sdk_x86.HP_Server_Stop(pServer);
            }
        }
        /// <summary>
        /// 用户通过该方法向指定客户端发送数据
        /// </summary>
        /// <param name="pServer"></param>
        /// <param name="connId">连接 ID</param>
        /// <param name="pBuffer">发送数据长度</param>
        /// <param name="length">发送数据长度</param>
        /// <returns></returns>
        public static bool HP_Server_Send(IntPtr pServer, IntPtr connId, byte[] pBuffer, int length)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Server_Send(pServer, connId, pBuffer, length);
            }
            else
            {
                return Sdk_x86.HP_Server_Send(pServer, connId, pBuffer, length);
            }
        }

        /// <summary>
        /// 用户通过该方法向指定客户端发送数据
        /// </summary>
        /// <param name="pServer"></param>
        /// <param name="connId">连接 ID</param>
        /// <param name="pBuffer">发送数据长度</param>
        /// <param name="length">发送数据长度</param>
        /// <returns></returns>
        public static bool HP_Server_Send(IntPtr pServer, IntPtr connId, IntPtr pBuffer, int length)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Server_Send(pServer, connId, pBuffer, length);
            }
            else
            {
                return Sdk_x86.HP_Server_Send(pServer, connId, pBuffer, length);
            }
        }

        /// <summary>
        /// 用户通过该方法向指定客户端发送数据
        /// </summary>
        /// <param name="pServer"></param>
        /// <param name="connId"></param>
        /// <param name="pBuffer"></param>
        /// <param name="length"></param>
        /// <param name="iOffset">针对pBuffer的偏移</param>
        /// <returns></returns>
        public static bool HP_Server_SendPart(IntPtr pServer, IntPtr connId, byte[] pBuffer, int length, int iOffset)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Server_SendPart(pServer, connId, pBuffer, length, iOffset);
            }
            else
            {
                return Sdk_x86.HP_Server_SendPart(pServer, connId, pBuffer, length, iOffset);
            }
        }

        /// <summary>
        /// 用户通过该方法向指定客户端发送数据
        /// </summary>
        /// <param name="pServer"></param>
        /// <param name="connId"></param>
        /// <param name="pBuffer"></param>
        /// <param name="length"></param>
        /// <param name="iOffset">针对pBuffer的偏移</param>
        /// <returns></returns>
        public static bool HP_Server_SendPart(IntPtr pServer, IntPtr connId, IntPtr pBuffer, int length, int iOffset)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Server_SendPart(pServer, connId, pBuffer, length, iOffset);
            }
            else
            {
                return Sdk_x86.HP_Server_SendPart(pServer, connId, pBuffer, length, iOffset);
            }
        }


        /// <summary>
        /// 发送多组数据
        /// 向指定连接发送多组数据
        /// TCP - 顺序发送所有数据包 
        /// UDP - 把所有数据包组合成一个数据包发送（数据包的总长度不能大于设置的 UDP 包最大长度） 
        /// </summary>
        /// <param name="pServer"></param>
        /// <param name="connId">连接 ID</param>
        /// <param name="pBuffers">发送缓冲区数组</param>
        /// <param name="iCount">发送缓冲区数目</param>
        /// <returns>TRUE.成功,FALSE.失败，可通过 Windows API 函数 ::GetLastError() 获取 Windows 错误代码</returns>
        public static bool HP_Server_SendPackets(IntPtr pServer, IntPtr connId, WSABUF[] pBuffers, int iCount)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Server_SendPackets(pServer, connId, pBuffers, iCount);
            }
            else
            {
                return Sdk_x86.HP_Server_SendPackets(pServer, connId, pBuffers, iCount);
            }
        }


        /// <summary>
        /// 断开与某个客户端的连接
        /// </summary>
        /// <param name="pServer"></param>
        /// <param name="connId">连接 ID</param>
        /// <param name="bForce">是否强制断开连接</param>
        /// <returns></returns>

        public static bool HP_Server_Disconnect(IntPtr pServer, IntPtr connId, bool bForce)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Server_Disconnect(pServer, connId, bForce);
            }
            else
            {
                return Sdk_x86.HP_Server_Disconnect(pServer, connId, bForce);
            }
        }

        /// <summary>
        /// 断开超过指定时长的连接
        /// </summary>
        /// <param name="pServer"></param>
        /// <param name="dwPeriod">时长（毫秒）</param>
        /// <param name="bForce">是否强制断开连接</param>
        /// <returns></returns>

        public static bool HP_Server_DisconnectLongConnections(IntPtr pServer, uint dwPeriod, bool bForce)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Server_DisconnectLongConnections(pServer, dwPeriod, bForce);
            }
            else
            {
                return Sdk_x86.HP_Server_DisconnectLongConnections(pServer, dwPeriod, bForce);
            }
        }

        /// <summary>
        /// 断开超过指定时长的静默连接
        /// </summary>
        /// <param name="pServer"></param>
        /// <param name="dwPeriod">时长（毫秒）</param>
        /// <param name="bForce">是否强制断开连接</param>
        /// <returns></returns>

        public static bool HP_Server_DisconnectSilenceConnections(IntPtr pServer, uint dwPeriod, bool bForce)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Server_DisconnectSilenceConnections(pServer, dwPeriod, bForce);
            }
            else
            {
                return Sdk_x86.HP_Server_DisconnectSilenceConnections(pServer, dwPeriod, bForce);
            }
        }

        /******************************************************************************/
        /***************************** Server 属性访问方法 *****************************/

        /// <summary>
        /// 设置数据发送策略
        /// </summary>
        /// <param name="pServer"></param>
        /// <param name="enSendPolicy"></param>

        public static void HP_Server_SetSendPolicy(IntPtr pServer, SendPolicy enSendPolicy)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_Server_SetSendPolicy(pServer, enSendPolicy);
            }
            else
            {
                Sdk_x86.HP_Server_SetSendPolicy(pServer, enSendPolicy);
            }
        }

        /// <summary>
        /// 获取数据发送策略
        /// </summary>
        /// <param name="pServer"></param>
        /// <returns></returns>

        public static SendPolicy HP_Server_GetSendPolicy(IntPtr pServer)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Server_GetSendPolicy(pServer);
            }
            else
            {
                return Sdk_x86.HP_Server_GetSendPolicy(pServer);
            }
        }

        /// <summary>
        /// 设置连接的附加数据
        /// 是否为连接绑定附加数据或者绑定什么样的数据，均由应用程序自身决定
        /// </summary>
        /// <param name="pServer"></param>
        /// <param name="connId">连接 ID</param>
        /// <param name="pExtra"></param>
        /// <returns>若返回 false 失败则为（无效的连接 ID）</returns>

        public static bool HP_Server_SetConnectionExtra(IntPtr pServer, IntPtr connId, IntPtr pExtra)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Server_SetConnectionExtra(pServer, connId, pExtra);
            }
            else
            {
                return Sdk_x86.HP_Server_SetConnectionExtra(pServer, connId, pExtra);
            }
        }

        /// <summary>
        /// 获取连接的附加数据
        /// 是否为连接绑定附加数据或者绑定什么样的数据，均由应用程序自身决定
        /// </summary>
        /// <param name="pServer"></param>
        /// <param name="connId">连接 ID</param>
        /// <param name="pExtra">数据指针</param>
        /// <returns>若返回 false 失败则为（无效的连接 ID）</returns>

        public static bool HP_Server_GetConnectionExtra(IntPtr pServer, IntPtr connId, ref IntPtr pExtra)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Server_GetConnectionExtra(pServer, connId, ref  pExtra);
            }
            else
            {
                return Sdk_x86.HP_Server_GetConnectionExtra(pServer, connId, ref  pExtra);
            }
        }

        /// <summary>
        /// 检查通信组件是否已启动
        /// </summary>
        /// <param name="pServer"></param>
        /// <returns></returns>

        public static bool HP_Server_HasStarted(IntPtr pServer)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Server_HasStarted(pServer);
            }
            else
            {
                return Sdk_x86.HP_Server_HasStarted(pServer);
            }
        }

        /// <summary>
        /// 查看通信组件当前状态
        /// </summary>
        /// <param name="pServer"></param>
        /// <returns></returns>

        public static ServiceState HP_Server_GetState(IntPtr pServer)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Server_GetState(pServer);
            }
            else
            {
                return Sdk_x86.HP_Server_GetState(pServer);
            }
        }

        /// <summary>
        /// 获取最近一次失败操作的错误代码
        /// </summary>
        /// <param name="pServer"></param>
        /// <returns></returns>

        public static SocketError HP_Server_GetLastError(IntPtr pServer)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Server_GetLastError(pServer);
            }
            else
            {
                return Sdk_x86.HP_Server_GetLastError(pServer);
            }
        }

        /// <summary>
        /// 获取最近一次失败操作的错误描述
        /// </summary>
        /// <param name="pServer"></param>
        /// <returns></returns>

        public static IntPtr HP_Server_GetLastErrorDesc(IntPtr pServer)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Server_GetLastErrorDesc(pServer);
            }
            else
            {
                return Sdk_x86.HP_Server_GetLastErrorDesc(pServer);
            }
        }


        /// <summary>
        /// 获取连接中未发出数据的长度
        /// </summary>
        /// <param name="pServer"></param>
        /// <param name="connId"></param>
        /// <param name="piPending"></param>
        /// <returns></returns>

        public static bool HP_Server_GetPendingDataLength(IntPtr pServer, IntPtr connId, ref int piPending)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Server_GetPendingDataLength(pServer, connId, ref  piPending);
            }
            else
            {
                return Sdk_x86.HP_Server_GetPendingDataLength(pServer, connId, ref  piPending);
            }
        }

        /// <summary>
        /// 获取客户端连接数
        /// </summary>
        /// <param name="pServer"></param>
        /// <returns></returns>

        public static uint HP_Server_GetConnectionCount(IntPtr pServer)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Server_GetConnectionCount(pServer);
            }
            else
            {
                return Sdk_x86.HP_Server_GetConnectionCount(pServer);
            }
        }

        /// <summary>
        /// 获取所有连接的 CONNID
        /// </summary>
        /// <param name="pServer"></param>
        /// <param name="pIDs"></param>
        /// <param name="pdwCount"></param>
        /// <returns></returns>

        public static bool HP_Server_GetAllConnectionIDs(IntPtr pServer, IntPtr[] pIDs, ref uint pdwCount)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Server_GetAllConnectionIDs(pServer, pIDs, ref  pdwCount);
            }
            else
            {
                return Sdk_x86.HP_Server_GetAllConnectionIDs(pServer, pIDs, ref  pdwCount);
            }
        }

        /// <summary>
        /// 获取某个客户端连接时长（毫秒）
        /// </summary>
        /// <param name="pServer"></param>
        /// <param name="connId"></param>
        /// <param name="pdwPeriod"></param>
        /// <returns></returns>

        public static bool HP_Server_GetConnectPeriod(IntPtr pServer, IntPtr connId, ref uint pdwPeriod)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Server_GetConnectPeriod(pServer, connId, ref  pdwPeriod);
            }
            else
            {
                return Sdk_x86.HP_Server_GetConnectPeriod(pServer, connId, ref  pdwPeriod);
            }
        }

        /// <summary>
        /// 获取某个连接静默时间（毫秒）
        /// </summary>
        /// <param name="pServer"></param>
        /// <param name="connId"></param>
        /// <param name="pdwPeriod"></param>
        /// <returns></returns>

        public static bool HP_Server_GetSilencePeriod(IntPtr pServer, IntPtr connId, ref uint pdwPeriod)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Server_GetSilencePeriod(pServer, connId, ref  pdwPeriod);
            }
            else
            {
                return Sdk_x86.HP_Server_GetSilencePeriod(pServer, connId, ref  pdwPeriod);
            }
        }

        /// <summary>
        /// 获取监听 Socket 的地址信息
        /// </summary>
        /// <param name="pServer"></param>
        /// <param name="lpszAddress"></param>
        /// <param name="piAddressLen"></param>
        /// <param name="pusPort"></param>
        /// <returns></returns>

        public static bool HP_Server_GetListenAddress(IntPtr pServer, [MarshalAs(UnmanagedType.LPWStr)] StringBuilder lpszAddress, ref int piAddressLen, ref ushort pusPort)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Server_GetListenAddress(pServer, lpszAddress, ref  piAddressLen, ref  pusPort);
            }
            else
            {
                return Sdk_x86.HP_Server_GetListenAddress(pServer, lpszAddress, ref  piAddressLen, ref  pusPort);
            }
        }

        /// <summary>
        /// 获取某个客户端连接的地址信息
        /// </summary>
        /// <param name="pServer"></param>
        /// <param name="connId"></param>
        /// <param name="lpszAddress"></param>
        /// <param name="piAddressLen">传入传出值,大小最好在222.222.222.222的长度以上</param>
        /// <param name="pusPort"></param>
        /// <returns></returns>

        public static bool HP_Server_GetRemoteAddress(IntPtr pServer, IntPtr connId, [MarshalAs(UnmanagedType.LPWStr)] StringBuilder lpszAddress, ref int piAddressLen, ref ushort pusPort)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Server_GetRemoteAddress(pServer, connId, lpszAddress, ref  piAddressLen, ref  pusPort);
            }
            else
            {
                return Sdk_x86.HP_Server_GetRemoteAddress(pServer, connId, lpszAddress, ref  piAddressLen, ref  pusPort);
            }
        }


        /// <summary>
        /// 设置 Socket 缓存对象锁定时间（毫秒，在锁定期间该 Socket 缓存对象不能被获取使用）
        /// </summary>
        /// <param name="pServer"></param>
        /// <param name="dwFreeSocketObjLockTime"></param>

        public static void HP_Server_SetFreeSocketObjLockTime(IntPtr pServer, uint dwFreeSocketObjLockTime)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_Server_SetFreeSocketObjLockTime(pServer, dwFreeSocketObjLockTime);
            }
            else
            {
                Sdk_x86.HP_Server_SetFreeSocketObjLockTime(pServer, dwFreeSocketObjLockTime);
            }
        }

        /// <summary>
        /// 设置 Socket 缓存池大小（通常设置为平均并发连接数量的 1/3 - 1/2）
        /// </summary>
        /// <param name="pServer"></param>
        /// <param name="dwFreeSocketObjPool"></param>

        public static void HP_Server_SetFreeSocketObjPool(IntPtr pServer, uint dwFreeSocketObjPool)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_Server_SetFreeSocketObjPool(pServer, dwFreeSocketObjPool);
            }
            else
            {
                Sdk_x86.HP_Server_SetFreeSocketObjPool(pServer, dwFreeSocketObjPool);
            }
        }

        /// <summary>
        /// 设置内存块缓存池大小（通常设置为 Socket 缓存池大小的 2 - 3 倍）
        /// </summary>
        /// <param name="pServer"></param>
        /// <param name="dwFreeBufferObjPool"></param>

        public static void HP_Server_SetFreeBufferObjPool(IntPtr pServer, uint dwFreeBufferObjPool)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_Server_SetFreeBufferObjPool(pServer, dwFreeBufferObjPool);
            }
            else
            {
                Sdk_x86.HP_Server_SetFreeBufferObjPool(pServer, dwFreeBufferObjPool);
            }
        }

        /// <summary>
        /// 设置 Socket 缓存池回收阀值（通常设置为 Socket 缓存池大小的 3 倍）
        /// </summary>
        /// <param name="pServer"></param>
        /// <param name="dwFreeSocketObjHold"></param>

        public static void HP_Server_SetFreeSocketObjHold(IntPtr pServer, uint dwFreeSocketObjHold)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_Server_SetFreeSocketObjHold(pServer, dwFreeSocketObjHold);
            }
            else
            {
                Sdk_x86.HP_Server_SetFreeSocketObjHold(pServer, dwFreeSocketObjHold);
            }
        }

        /// <summary>
        /// 设置内存块缓存池回收阀值（通常设置为内存块缓存池大小的 3 倍）
        /// </summary>
        /// <param name="pServer"></param>
        /// <param name="dwFreeBufferObjHold"></param>

        public static void HP_Server_SetFreeBufferObjHold(IntPtr pServer, uint dwFreeBufferObjHold)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_Server_SetFreeBufferObjHold(pServer, dwFreeBufferObjHold);
            }
            else
            {
                Sdk_x86.HP_Server_SetFreeBufferObjHold(pServer, dwFreeBufferObjHold);
            }
        }

        /// <summary>
        /// 设置工作线程数量（通常设置为 2 * CPU + 2）
        /// </summary>
        /// <param name="pServer"></param>
        /// <param name="dwWorkerThreadCount"></param>

        public static void HP_Server_SetWorkerThreadCount(IntPtr pServer, uint dwWorkerThreadCount)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_Server_SetWorkerThreadCount(pServer, dwWorkerThreadCount);
            }
            else
            {
                Sdk_x86.HP_Server_SetWorkerThreadCount(pServer, dwWorkerThreadCount);
            }
        }

        /// <summary>
        /// 设置是否标记静默时间（设置为 TRUE 时 DisconnectSilenceConnections() 和 GetSilencePeriod() 才有效，默认：FALSE）
        /// </summary>
        /// <param name="pServer"></param>
        /// <param name="bMarkSilence"></param>

        public static void HP_Server_SetMarkSilence(IntPtr pServer, bool bMarkSilence)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_Server_SetMarkSilence(pServer, bMarkSilence);
            }
            else
            {
                Sdk_x86.HP_Server_SetMarkSilence(pServer, bMarkSilence);
            }
        }

        /// <summary>
        /// 获取 Socket 缓存对象锁定时间
        /// </summary>
        /// <param name="pServer"></param>
        /// <returns></returns>

        public static uint HP_Server_GetFreeSocketObjLockTime(IntPtr pServer)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Server_GetFreeSocketObjLockTime(pServer);
            }
            else
            {
                return Sdk_x86.HP_Server_GetFreeSocketObjLockTime(pServer);
            }
        }

        /// <summary>
        /// 获取 Socket 缓存池大小
        /// </summary>
        /// <param name="pServer"></param>
        /// <returns></returns>

        public static uint HP_Server_GetFreeSocketObjPool(IntPtr pServer)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Server_GetFreeSocketObjPool(pServer);
            }
            else
            {
                return Sdk_x86.HP_Server_GetFreeSocketObjPool(pServer);
            }
        }

        /// <summary>
        /// 获取内存块缓存池大小
        /// </summary>
        /// <param name="pServer"></param>
        /// <returns></returns>

        public static uint HP_Server_GetFreeBufferObjPool(IntPtr pServer)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Server_GetFreeBufferObjPool(pServer);
            }
            else
            {
                return Sdk_x86.HP_Server_GetFreeBufferObjPool(pServer);
            }
        }

        /// <summary>
        /// 获取 Socket 缓存池回收阀值
        /// </summary>
        /// <param name="pServer"></param>
        /// <returns></returns>

        public static uint HP_Server_GetFreeSocketObjHold(IntPtr pServer)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Server_GetFreeSocketObjHold(pServer);
            }
            else
            {
                return Sdk_x86.HP_Server_GetFreeSocketObjHold(pServer);
            }
        }

        /// <summary>
        /// 获取内存块缓存池回收阀值
        /// </summary>
        /// <param name="pServer"></param>
        /// <returns></returns>

        public static uint HP_Server_GetFreeBufferObjHold(IntPtr pServer)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Server_GetFreeBufferObjHold(pServer);
            }
            else
            {
                return Sdk_x86.HP_Server_GetFreeBufferObjHold(pServer);
            }
        }

        /// <summary>
        /// 获取工作线程数量
        /// </summary>
        /// <param name="pServer"></param>
        /// <returns></returns>

        public static uint HP_Server_GetWorkerThreadCount(IntPtr pServer)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Server_GetWorkerThreadCount(pServer);
            }
            else
            {
                return Sdk_x86.HP_Server_GetWorkerThreadCount(pServer);
            }
        }

        /// <summary>
        /// 检测是否标记静默时间
        /// </summary>
        /// <param name="pServer"></param>
        /// <returns></returns>

        public static bool HP_Server_IsMarkSilence(IntPtr pServer)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Server_IsMarkSilence(pServer);
            }
            else
            {
                return Sdk_x86.HP_Server_IsMarkSilence(pServer);
            }
        }

        /**********************************************************************************/
        /***************************** TCP Server 操作方法 *****************************/

        /// <summary>
        ///  名称：发送小文件
        ///  描述：向指定连接发送 4096 KB 以下的小文件
        /// </summary>
        /// <param name="pServer"></param>
        /// <param name="connId">连接 ID</param>
        /// <param name="lpszFileName">文件路径</param>
        /// <param name="pHead">头部附加数据</param>
        /// <param name="pTail">尾部附加数据</param>
        /// <returns>TRUE.成功 FALSE	-- 失败，可通过 Windows API 函数 ::GetLastError() 获取 Windows 错误代码</returns>
        public static bool HP_TcpServer_SendSmallFile(IntPtr pServer, IntPtr connId, string lpszFileName, ref WSABUF pHead, ref WSABUF pTail)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_TcpServer_SendSmallFile(pServer, connId, lpszFileName, ref  pHead, ref  pTail);
            }
            else
            {
                return Sdk_x86.HP_TcpServer_SendSmallFile(pServer, connId, lpszFileName, ref  pHead, ref  pTail);
            }
        }

        /**********************************************************************************/
        /***************************** TCP Server 属性访问方法 *****************************/

        /// <summary>
        /// 设置 Accept 预投递数量（根据负载调整设置，Accept 预投递数量越大则支持的并发连接请求越多）
        /// </summary>
        /// <param name="pServer"></param>
        /// <param name="dwAcceptSocketCount"></param>

        public static void HP_TcpServer_SetAcceptSocketCount(IntPtr pServer, uint dwAcceptSocketCount)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_TcpServer_SetAcceptSocketCount(pServer, dwAcceptSocketCount);
            }
            else
            {
                Sdk_x86.HP_TcpServer_SetAcceptSocketCount(pServer, dwAcceptSocketCount);
            }
        }

        /// <summary>
        /// 设置通信数据缓冲区大小（根据平均通信数据包大小调整设置，通常设置为 1024 的倍数）
        /// </summary>
        /// <param name="pServer"></param>
        /// <param name="dwSocketBufferSize"></param>

        public static void HP_TcpServer_SetSocketBufferSize(IntPtr pServer, uint dwSocketBufferSize)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_TcpServer_SetSocketBufferSize(pServer, dwSocketBufferSize);
            }
            else
            {
                Sdk_x86.HP_TcpServer_SetSocketBufferSize(pServer, dwSocketBufferSize);
            }
        }

        /// <summary>
        /// 设置监听 Socket 的等候队列大小（根据并发连接数量调整设置）
        /// </summary>
        /// <param name="pServer"></param>
        /// <param name="dwSocketListenQueue"></param>

        public static void HP_TcpServer_SetSocketListenQueue(IntPtr pServer, uint dwSocketListenQueue)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_TcpServer_SetSocketListenQueue(pServer, dwSocketListenQueue);
            }
            else
            {
                Sdk_x86.HP_TcpServer_SetSocketListenQueue(pServer, dwSocketListenQueue);
            }
        }

        /// <summary>
        /// 设置心跳包间隔（毫秒，0 则不发送心跳包）
        /// </summary>
        /// <param name="pServer"></param>
        /// <param name="dwKeepAliveTime"></param>

        public static void HP_TcpServer_SetKeepAliveTime(IntPtr pServer, uint dwKeepAliveTime)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_TcpServer_SetKeepAliveTime(pServer, dwKeepAliveTime);
            }
            else
            {
                Sdk_x86.HP_TcpServer_SetKeepAliveTime(pServer, dwKeepAliveTime);
            }
        }

        /// <summary>
        /// 设置心跳确认包检测间隔（毫秒，0 不发送心跳包，如果超过若干次 [默认：WinXP 5 次, Win7 10 次] 检测不到心跳确认包则认为已断线）
        /// </summary>
        /// <param name="pServer"></param>
        /// <param name="dwKeepAliveInterval"></param>

        public static void HP_TcpServer_SetKeepAliveInterval(IntPtr pServer, uint dwKeepAliveInterval)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_TcpServer_SetKeepAliveInterval(pServer, dwKeepAliveInterval);
            }
            else
            {
                Sdk_x86.HP_TcpServer_SetKeepAliveInterval(pServer, dwKeepAliveInterval);
            }
        }


        /// <summary>
        /// 获取 Accept 预投递数量
        /// </summary>
        /// <param name="pServer"></param>
        /// <returns></returns>

        public static uint HP_TcpServer_GetAcceptSocketCount(IntPtr pServer)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_TcpServer_GetAcceptSocketCount(pServer);
            }
            else
            {
                return Sdk_x86.HP_TcpServer_GetAcceptSocketCount(pServer);
            }
        }

        /// <summary>
        /// 获取通信数据缓冲区大小
        /// </summary>
        /// <param name="pServer"></param>
        /// <returns></returns>

        public static uint HP_TcpServer_GetSocketBufferSize(IntPtr pServer)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_TcpServer_GetSocketBufferSize(pServer);
            }
            else
            {
                return Sdk_x86.HP_TcpServer_GetSocketBufferSize(pServer);
            }
        }

        /// <summary>
        /// 获取监听 Socket 的等候队列大小
        /// </summary>
        /// <param name="pServer"></param>
        /// <returns></returns>

        public static uint HP_TcpServer_GetSocketListenQueue(IntPtr pServer)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_TcpServer_GetSocketListenQueue(pServer);
            }
            else
            {
                return Sdk_x86.HP_TcpServer_GetSocketListenQueue(pServer);
            }
        }

        /// <summary>
        /// 获取心跳检查次数
        /// </summary>
        /// <param name="pServer"></param>
        /// <returns></returns>

        public static uint HP_TcpServer_GetKeepAliveTime(IntPtr pServer)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_TcpServer_GetKeepAliveTime(pServer);
            }
            else
            {
                return Sdk_x86.HP_TcpServer_GetKeepAliveTime(pServer);
            }
        }

        /// <summary>
        /// 获取心跳检查间隔
        /// </summary>
        /// <param name="pServer"></param>
        /// <returns></returns>

        public static uint HP_TcpServer_GetKeepAliveInterval(IntPtr pServer)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_TcpServer_GetKeepAliveInterval(pServer);
            }
            else
            {
                return Sdk_x86.HP_TcpServer_GetKeepAliveInterval(pServer);
            }
        }


        /**********************************************************************************/
        /***************************** UDP Server 属性访问方法 *****************************/

        /// <summary>
        /// 设置数据报文最大长度（建议在局域网环境下不超过 1472 字节，在广域网环境下不超过 548 字节）
        /// </summary>
        /// <param name="pServer"></param>
        /// <param name="dwMaxDatagramSize"></param>

        public static void HP_UdpServer_SetMaxDatagramSize(IntPtr pServer, uint dwMaxDatagramSize)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_UdpServer_SetMaxDatagramSize(pServer, dwMaxDatagramSize);
            }
            else
            {
                Sdk_x86.HP_UdpServer_SetMaxDatagramSize(pServer, dwMaxDatagramSize);
            }
        }

        /// <summary>
        /// 获取数据报文最大长度
        /// </summary>
        /// <param name="pServer"></param>
        /// <returns></returns>

        public static uint HP_UdpServer_GetMaxDatagramSize(IntPtr pServer)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_UdpServer_GetMaxDatagramSize(pServer);
            }
            else
            {
                return Sdk_x86.HP_UdpServer_GetMaxDatagramSize(pServer);
            }
        }

        /// <summary>
        /// 设置 Receive 预投递数量（根据负载调整设置，Receive 预投递数量越大则丢包概率越小） 
        /// </summary>
        /// <param name="pServer"></param>
        /// <param name="dwPostReceiveCount"></param>

        public static void HP_UdpServer_SetPostReceiveCount(IntPtr pServer, uint dwPostReceiveCount)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_UdpServer_SetPostReceiveCount(pServer, dwPostReceiveCount);
            }
            else
            {
                Sdk_x86.HP_UdpServer_SetPostReceiveCount(pServer, dwPostReceiveCount);
            }
        }

        /// <summary>
        /// 获取 Receive 预投递数量
        /// </summary>
        /// <param name="pServer"></param>
        /// <returns></returns>

        public static uint HP_UdpServer_GetPostReceiveCount(IntPtr pServer)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_UdpServer_GetPostReceiveCount(pServer);
            }
            else
            {
                return Sdk_x86.HP_UdpServer_GetPostReceiveCount(pServer);
            }
        }

        /// <summary>
        /// 设置监测包尝试次数（0 则不发送监测跳包，如果超过最大尝试次数则认为已断线）
        /// </summary>
        /// <param name="pServer"></param>
        /// <param name="dwMaxDatagramSize"></param>

        public static void HP_UdpServer_SetDetectAttempts(IntPtr pServer, uint dwMaxDatagramSize)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_UdpServer_SetDetectAttempts(pServer, dwMaxDatagramSize);
            }
            else
            {
                Sdk_x86.HP_UdpServer_SetDetectAttempts(pServer, dwMaxDatagramSize);
            }
        }

        /// <summary>
        /// 设置监测包发送间隔（秒，0 不发送监测包）
        /// </summary>
        /// <param name="pServer"></param>
        /// <param name="dwMaxDatagramSize"></param>

        public static void HP_UdpServer_SetDetectInterval(IntPtr pServer, uint dwMaxDatagramSize)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_UdpServer_SetDetectInterval(pServer, dwMaxDatagramSize);
            }
            else
            {
                Sdk_x86.HP_UdpServer_SetDetectInterval(pServer, dwMaxDatagramSize);
            }
        }

        /// <summary>
        /// 获取心跳检查次数
        /// </summary>
        /// <param name="pServer"></param>
        /// <returns></returns>

        public static uint HP_UdpServer_GetDetectAttempts(IntPtr pServer)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_UdpServer_GetDetectAttempts(pServer);
            }
            else
            {
                return Sdk_x86.HP_UdpServer_GetDetectAttempts(pServer);
            }
        }

        /// <summary>
        /// 获取心跳检查间隔
        /// </summary>
        /// <param name="pServer"></param>
        /// <returns></returns>

        public static uint HP_UdpServer_GetDetectInterval(IntPtr pServer)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_UdpServer_GetDetectInterval(pServer);
            }
            else
            {
                return Sdk_x86.HP_UdpServer_GetDetectInterval(pServer);
            }
        }
        /******************************************************************************/
        /***************************** Client 组件操作方法 *****************************/

        /// <summary>
        /// 启动客户端通信组件并连接服务端，启动完成后可开始收发数据
        /// </summary>
        /// <param name="pClient"></param>
        /// <param name="pszRemoteAddress">服务端地址</param>
        /// <param name="usPort">服务端端口</param>
        /// <param name="bAsyncConnect">是否采用异步 Connnect</param>
        /// <returns>失败，可通过 GetLastError() 获取错误代码</returns>
        public static bool HP_Client_Start(IntPtr pClient, string pszRemoteAddress, ushort usPort, bool bAsyncConnect)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Client_Start(pClient, pszRemoteAddress, usPort, bAsyncConnect);
            }
            else
            {
                return Sdk_x86.HP_Client_Start(pClient, pszRemoteAddress, usPort, bAsyncConnect);
            }
        }

        /// <summary>
        /// 启动通信组件（并指定绑定地址）, 启动客户端通信组件并连接服务端，启动完成后可开始收发数据
        /// </summary>
        /// <param name="pClient"></param>
        /// <param name="lpszRemoteAddress">服务端地址</param>
        /// <param name="usPort">服务端端口</param>
        /// <param name="bAsyncConnect">是否采用异步 Connect</param>
        /// <param name="lpszBindAddress">绑定地址（默认：nullptr，TcpClient/UdpClient -> 不执行绑定操作，UdpCast 绑定 -> 0.0.0.0）</param>
        /// <returns>失败，可通过 HP_Client_GetLastError() 获取错误代码</returns>
        public static bool HP_Client_StartWithBindAddress(IntPtr pClient, string lpszRemoteAddress, ushort usPort, bool bAsyncConnect, string lpszBindAddress)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Client_StartWithBindAddress(pClient, lpszRemoteAddress, usPort, bAsyncConnect, lpszBindAddress);
            }
            else
            {
                return Sdk_x86.HP_Client_StartWithBindAddress(pClient, lpszRemoteAddress, usPort, bAsyncConnect, lpszBindAddress);
            }
        }

        /// <summary>
        /// 关闭客户端通信组件，关闭完成后断开与服务端的连接并释放所有资源
        /// </summary>
        /// <param name="pClient"></param>
        /// <returns>失败，可通过 GetLastError() 获取错误代码</returns>

        public static bool HP_Client_Stop(IntPtr pClient)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Client_Stop(pClient);
            }
            else
            {
                return Sdk_x86.HP_Client_Stop(pClient);
            }
        }

        /// <summary>
        /// 用户通过该方法向服务端发送数据
        /// </summary>
        /// <param name="pClient"></param>
        /// <param name="connId">连接 ID（保留参数，目前该参数并未使用）</param>
        /// <param name="pBuffer">发送数据缓冲区</param>
        /// <param name="length">发送数据长度</param>
        /// <returns>失败，可通过 GetLastError() 获取错误代码</returns>
        public static bool HP_Client_Send(IntPtr pClient, byte[] pBuffer, int length)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Client_Send(pClient, pBuffer, length);
            }
            else
            {
                return Sdk_x86.HP_Client_Send(pClient, pBuffer, length);
            }
        }

        /// <summary>
        /// 用户通过该方法向服务端发送数据
        /// </summary>
        /// <param name="pClient"></param>
        /// <param name="connId">连接 ID（保留参数，目前该参数并未使用）</param>
        /// <param name="pBuffer">发送数据缓冲区</param>
        /// <param name="length">发送数据长度</param>
        /// <returns>失败，可通过 GetLastError() 获取错误代码</returns>
        public static bool HP_Client_Send(IntPtr pClient, IntPtr pBuffer, int length)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Client_Send(pClient, pBuffer, length);
            }
            else
            {
                return Sdk_x86.HP_Client_Send(pClient, pBuffer, length);
            }
        }

        /// <summary>
        /// 用户通过该方法向服务端发送数据
        /// </summary>
        /// <param name="pClient"></param>
        /// <param name="pBuffer"></param>
        /// <param name="length"></param>
        /// <param name="iOffset">针对pBuffer的偏移</param>
        /// <returns></returns>
        public static bool HP_Client_SendPart(IntPtr pClient, byte[] pBuffer, int length, int iOffset)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Client_SendPart(pClient, pBuffer, length, iOffset);
            }
            else
            {
                return Sdk_x86.HP_Client_SendPart(pClient, pBuffer, length, iOffset);
            }
        }

        /// <summary>
        /// 用户通过该方法向服务端发送数据
        /// </summary>
        /// <param name="pClient"></param>
        /// <param name="pBuffer"></param>
        /// <param name="length"></param>
        /// <param name="iOffset">针对pBuffer的偏移</param>
        /// <returns></returns>
        public static bool HP_Client_SendPart(IntPtr pClient, IntPtr pBuffer, int length, int iOffset)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Client_SendPart(pClient, pBuffer, length, iOffset);
            }
            else
            {
                return Sdk_x86.HP_Client_SendPart(pClient, pBuffer, length, iOffset);
            }
        }


        /// <summary>
        /// 发送多组数据
        /// 向服务端发送多组数据
        /// TCP - 顺序发送所有数据包 
        /// UDP - 把所有数据包组合成一个数据包发送（数据包的总长度不能大于设置的 UDP 包最大长度） 
        /// </summary>
        /// <param name="pClient"></param>
        /// <param name="pBuffers">发送缓冲区数组</param>
        /// <param name="iCount">发送缓冲区数目</param>
        /// <returns>TRUE.成功,FALSE.失败，可通过 Windows API 函数 ::GetLastError() 获取 Windows 错误代码</returns>
        public static bool HP_Client_SendPackets(IntPtr pClient, WSABUF[] pBuffers, int iCount)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Client_SendPackets(pClient, pBuffers, iCount);
            }
            else
            {
                return Sdk_x86.HP_Client_SendPackets(pClient, pBuffers, iCount);
            }
        }


        /******************************************************************************/
        /***************************** Client 属性访问方法 *****************************/

        /// <summary>
        /// 设置连接的附加数据
        /// </summary>
        /// <param name="pClient"></param>
        /// <param name="pExtra"></param>

        public static void HP_Client_SetExtra(IntPtr pClient, IntPtr pExtra)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_Client_SetExtra(pClient, pExtra);
            }
            else
            {
                Sdk_x86.HP_Client_SetExtra(pClient, pExtra);
            }
        }


        /// <summary>
        /// 获取连接的附加数据
        /// </summary>
        /// <param name="pClient"></param>
        /// <returns></returns>

        public static IntPtr HP_Client_GetExtra(IntPtr pClient)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Client_GetExtra(pClient);
            }
            else
            {
                return Sdk_x86.HP_Client_GetExtra(pClient);
            }
        }


        /// <summary>
        /// 检查通信组件是否已启动
        /// </summary>
        /// <param name="pClient"></param>
        /// <returns></returns>

        public static bool HP_Client_HasStarted(IntPtr pClient)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Client_HasStarted(pClient);
            }
            else
            {
                return Sdk_x86.HP_Client_HasStarted(pClient);
            }
        }

        /// <summary>
        /// 查看通信组件当前状态
        /// </summary>
        /// <param name="pClient"></param>
        /// <returns></returns>

        public static ServiceState HP_Client_GetState(IntPtr pClient)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Client_GetState(pClient);
            }
            else
            {
                return Sdk_x86.HP_Client_GetState(pClient);
            }
        }

        /// <summary>
        /// 获取最近一次失败操作的错误代码
        /// </summary>
        /// <param name="pClient"></param>
        /// <returns></returns>

        public static SocketError HP_Client_GetLastError(IntPtr pClient)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Client_GetLastError(pClient);
            }
            else
            {
                return Sdk_x86.HP_Client_GetLastError(pClient);
            }
        }

        /// <summary>
        /// 获取最近一次失败操作的错误描述
        /// </summary>
        /// <param name="pClient"></param>
        /// <returns></returns>

        public static IntPtr HP_Client_GetLastErrorDesc(IntPtr pClient)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Client_GetLastErrorDesc(pClient);
            }
            else
            {
                return Sdk_x86.HP_Client_GetLastErrorDesc(pClient);
            }
        }

        /// <summary>
        /// 获取该组件对象的连接 ID
        /// </summary>
        /// <param name="pClient"></param>
        /// <returns></returns>

        public static IntPtr HP_Client_GetConnectionID(IntPtr pClient)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Client_GetConnectionID(pClient);
            }
            else
            {
                return Sdk_x86.HP_Client_GetConnectionID(pClient);
            }
        }

        /// <summary>
        /// 获取 Client Socket 的地址信息
        /// </summary>
        /// <param name="pClient"></param>
        /// <param name="lpszAddress"></param>
        /// <param name="piAddressLen"></param>
        /// <param name="pusPort"></param>
        /// <returns></returns>

        public static bool HP_Client_GetLocalAddress(IntPtr pClient, [MarshalAs(UnmanagedType.LPWStr)] StringBuilder lpszAddress, ref int piAddressLen, ref ushort pusPort)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Client_GetLocalAddress(pClient, lpszAddress, ref  piAddressLen, ref  pusPort);
            }
            else
            {
                return Sdk_x86.HP_Client_GetLocalAddress(pClient, lpszAddress, ref  piAddressLen, ref  pusPort);
            }
        }

        /// <summary>
        /// 获取连接中未发出数据的长度
        /// </summary>
        /// <param name="pClient"></param>
        /// <param name="piPending"></param>
        /// <returns></returns>

        public static bool HP_Client_GetPendingDataLength(IntPtr pClient, ref int piPending)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Client_GetPendingDataLength(pClient, ref  piPending);
            }
            else
            {
                return Sdk_x86.HP_Client_GetPendingDataLength(pClient, ref  piPending);
            }
        }

        /// <summary>
        /// 设置内存块缓存池大小（通常设置为 -> PUSH 模型：5 - 10；PULL 模型：10 - 20 ）
        /// </summary>
        /// <param name="pClient"></param>
        /// <param name="dwFreeBufferPoolSize"></param>

        public static void HP_Client_SetFreeBufferPoolSize(IntPtr pClient, uint dwFreeBufferPoolSize)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_Client_SetFreeBufferPoolSize(pClient, dwFreeBufferPoolSize);
            }
            else
            {
                Sdk_x86.HP_Client_SetFreeBufferPoolSize(pClient, dwFreeBufferPoolSize);
            }
        }

        /// <summary>
        /// 设置内存块缓存池回收阀值（通常设置为内存块缓存池大小的 3 倍）
        /// </summary>
        /// <param name="pClient"></param>
        /// <param name="dwFreeBufferPoolHold"></param>

        public static void HP_Client_SetFreeBufferPoolHold(IntPtr pClient, uint dwFreeBufferPoolHold)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_Client_SetFreeBufferPoolHold(pClient, dwFreeBufferPoolHold);
            }
            else
            {
                Sdk_x86.HP_Client_SetFreeBufferPoolHold(pClient, dwFreeBufferPoolHold);
            }
        }

        /// <summary>
        /// 获取内存块缓存池大小
        /// </summary>
        /// <param name="pClient"></param>

        public static uint HP_Client_GetFreeBufferPoolSize(IntPtr pClient)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Client_GetFreeBufferPoolSize(pClient);
            }
            else
            {
                return Sdk_x86.HP_Client_GetFreeBufferPoolSize(pClient);
            }
        }

        /// <summary>
        /// 获取内存块缓存池回收阀值
        /// </summary>
        /// <param name="pClient"></param>

        public static uint HP_Client_GetFreeBufferPoolHold(IntPtr pClient)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Client_GetFreeBufferPoolHold(pClient);
            }
            else
            {
                return Sdk_x86.HP_Client_GetFreeBufferPoolHold(pClient);
            }
        }
        /**********************************************************************************/
        /***************************** TCP Client 操作方法 *****************************/

        /// <summary>
        ///  名称：发送小文件
        ///  描述：向指定连接发送 4096 KB 以下的小文件
        /// </summary>
        /// <param name="pServer"></param>
        /// <param name="lpszFileName">文件路径</param>
        /// <param name="pHead">头部附加数据</param>
        /// <param name="pTail">尾部附加数据</param>
        /// <returns>TRUE.成功 FALSE	-- 失败，可通过 Windows API 函数 ::GetLastError() 获取 Windows 错误代码</returns>
        public static bool HP_TcpClient_SendSmallFile(IntPtr pClient, string lpszFileName, ref WSABUF pHead, ref WSABUF pTail)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_TcpClient_SendSmallFile(pClient, lpszFileName, ref  pHead, ref  pTail);
            }
            else
            {
                return Sdk_x86.HP_TcpClient_SendSmallFile(pClient, lpszFileName, ref  pHead, ref  pTail);
            }
        }

        /**********************************************************************************/
        /***************************** TCP Client 属性访问方法 *****************************/

        /// <summary>
        /// 设置通信数据缓冲区大小（根据平均通信数据包大小调整设置，通常设置为：(N * 1024) - sizeof(TBufferObj)）
        /// </summary>
        /// <param name="pClient"></param>
        /// <param name="dwSocketBufferSize"></param>

        public static void HP_TcpClient_SetSocketBufferSize(IntPtr pClient, uint dwSocketBufferSize)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_TcpClient_SetSocketBufferSize(pClient, dwSocketBufferSize);
            }
            else
            {
                Sdk_x86.HP_TcpClient_SetSocketBufferSize(pClient, dwSocketBufferSize);
            }
        }

        /// <summary>
        /// 设置心跳包间隔（毫秒，0 则不发送心跳包）
        /// </summary>
        /// <param name="pClient"></param>
        /// <param name="dwKeepAliveTime"></param>

        public static void HP_TcpClient_SetKeepAliveTime(IntPtr pClient, uint dwKeepAliveTime)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_TcpClient_SetKeepAliveTime(pClient, dwKeepAliveTime);
            }
            else
            {
                Sdk_x86.HP_TcpClient_SetKeepAliveTime(pClient, dwKeepAliveTime);
            }
        }

        /// <summary>
        /// 设置心跳确认包检测间隔（毫秒，0 不发送心跳包，如果超过若干次 [默认：WinXP 5 次, Win7 10 次] 检测不到心跳确认包则认为已断线）
        /// </summary>
        /// <param name="pClient"></param>
        /// <param name="dwKeepAliveInterval"></param>

        public static void HP_TcpClient_SetKeepAliveInterval(IntPtr pClient, uint dwKeepAliveInterval)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_TcpClient_SetKeepAliveInterval(pClient, dwKeepAliveInterval);
            }
            else
            {
                Sdk_x86.HP_TcpClient_SetKeepAliveInterval(pClient, dwKeepAliveInterval);
            }
        }

        /// <summary>
        /// 获取通信数据缓冲区大小
        /// </summary>
        /// <param name="pClient"></param>
        /// <returns></returns>

        public static uint HP_TcpClient_GetSocketBufferSize(IntPtr pClient)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_TcpClient_GetSocketBufferSize(pClient);
            }
            else
            {
                return Sdk_x86.HP_TcpClient_GetSocketBufferSize(pClient);
            }
        }

        /// <summary>
        /// 获取心跳检查次数
        /// </summary>
        /// <param name="pClient"></param>
        /// <returns></returns>

        public static uint HP_TcpClient_GetKeepAliveTime(IntPtr pClient)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_TcpClient_GetKeepAliveTime(pClient);
            }
            else
            {
                return Sdk_x86.HP_TcpClient_GetKeepAliveTime(pClient);
            }
        }

        /// <summary>
        /// 获取心跳检查间隔
        /// </summary>
        /// <param name="pClient"></param>
        /// <returns></returns>

        public static uint HP_TcpClient_GetKeepAliveInterval(IntPtr pClient)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_TcpClient_GetKeepAliveInterval(pClient);
            }
            else
            {
                return Sdk_x86.HP_TcpClient_GetKeepAliveInterval(pClient);
            }
        }

        /**********************************************************************************/
        /***************************** UDP Client 属性访问方法 *****************************/

        /// <summary>
        /// 设置数据报文最大长度（建议在局域网环境下不超过 1472 字节，在广域网环境下不超过 548 字节）
        /// </summary>
        /// <param name="pClient"></param>
        /// <param name="dwMaxDatagramSize"></param>

        public static void HP_UdpClient_SetMaxDatagramSize(IntPtr pClient, uint dwMaxDatagramSize)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_UdpClient_SetMaxDatagramSize(pClient, dwMaxDatagramSize);
            }
            else
            {
                Sdk_x86.HP_UdpClient_SetMaxDatagramSize(pClient, dwMaxDatagramSize);
            }
        }

        /// <summary>
        /// 获取数据报文最大长度
        /// </summary>
        /// <param name="pClient"></param>
        /// <returns></returns>

        public static uint HP_UdpClient_GetMaxDatagramSize(IntPtr pClient)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_UdpClient_GetMaxDatagramSize(pClient);
            }
            else
            {
                return Sdk_x86.HP_UdpClient_GetMaxDatagramSize(pClient);
            }
        }

        /// <summary>
        /// 设置监测包尝试次数（0 则不发送监测跳包，如果超过最大尝试次数则认为已断线
        /// </summary>
        /// <param name="pClient"></param>
        /// <param name="dwDetectAttempts"></param>

        public static void HP_UdpClient_SetDetectAttempts(IntPtr pClient, uint dwDetectAttempts)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_UdpClient_SetDetectAttempts(pClient, dwDetectAttempts);
            }
            else
            {
                Sdk_x86.HP_UdpClient_SetDetectAttempts(pClient, dwDetectAttempts);
            }
        }

        /// <summary>
        /// 设置监测包发送间隔（秒，0 不发送监测包）
        /// </summary>
        /// <param name="pClient"></param>
        /// <param name="dwDetectInterval"></param>

        public static void HP_UdpClient_SetDetectInterval(IntPtr pClient, uint dwDetectInterval)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_UdpClient_SetDetectInterval(pClient, dwDetectInterval);
            }
            else
            {
                Sdk_x86.HP_UdpClient_SetDetectInterval(pClient, dwDetectInterval);
            }
        }
        /// <summary>
        /// 获取心跳检查次数
        /// </summary>
        /// <param name="pClient"></param>
        /// <returns></returns>

        public static uint HP_UdpClient_GetDetectAttempts(IntPtr pClient)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_UdpClient_GetDetectAttempts(pClient);
            }
            else
            {
                return Sdk_x86.HP_UdpClient_GetDetectAttempts(pClient);
            }
        }

        /// <summary>
        /// 获取心跳检查间隔
        /// </summary>
        /// <param name="pClient"></param>
        /// <returns></returns>

        public static uint HP_UdpClient_GetDetectInterval(IntPtr pClient)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_UdpClient_GetDetectInterval(pClient);
            }
            else
            {
                return Sdk_x86.HP_UdpClient_GetDetectInterval(pClient);
            }
        }

        /**************************************************************************/
        /***************************** Agent 操作方法 *****************************/

        /// <summary>
        /// 启动通信组件
        /// 启动通信代理组件，启动完成后可开始连接远程服务器
        /// </summary>
        /// <param name="pAgent"></param>
        /// <param name="pszBindAddress">监听地址</param>
        /// <param name="bAsyncConnect">是否采用异步 Connect</param>
        /// <returns>失败，可通过 GetLastError() 获取错误代码</returns>
        public static bool HP_Agent_Start(IntPtr pAgent, String pszBindAddress, bool bAsyncConnect)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Agent_Start(pAgent, pszBindAddress, bAsyncConnect);
            }
            else
            {
                return Sdk_x86.HP_Agent_Start(pAgent, pszBindAddress, bAsyncConnect);
            }
        }

        /// <summary>
        /// 关闭通信组件
        /// 关闭通信组件，关闭完成后断开所有连接并释放所有资源
        /// </summary>
        /// <param name="pAgent"></param>
        /// <returns>-- 失败，可通过 GetLastError() 获取错误代码</returns>

        public static bool HP_Agent_Stop(IntPtr pAgent)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Agent_Stop(pAgent);
            }
            else
            {
                return Sdk_x86.HP_Agent_Stop(pAgent);
            }
        }

        /// <summary>
        /// 连接服务器
        /// 连接服务器，连接成功后 IAgentListener 会接收到 OnConnect() 事件
        /// </summary>
        /// <param name="pAgent"></param>
        /// <param name="pszBindAddress">服务端地址</param>
        /// <param name="usPort">服务端端口</param>
        /// <param name="pconnId">传出连接 ID</param>
        /// <returns>失败，可通过 SYS_GetLastError() 获取 Windows 错误代码</returns>
        public static bool HP_Agent_Connect(IntPtr pAgent, String pszBindAddress, ushort usPort, ref IntPtr pconnId)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Agent_Connect(pAgent, pszBindAddress, usPort, ref  pconnId);
            }
            else
            {
                return Sdk_x86.HP_Agent_Connect(pAgent, pszBindAddress, usPort, ref  pconnId);
            }
        }

        /// <summary>
        /// 发送数据
        /// 用户通过该方法向指定连接发送数据
        /// </summary>
        /// <param name="pAgent"></param>
        /// <param name="connId">连接 ID</param>
        /// <param name="pBuffer">发送数据缓冲区</param>
        /// <param name="length">发送数据长度</param>
        /// <returns></returns>
        public static bool HP_Agent_Send(IntPtr pAgent, IntPtr connId, byte[] pBuffer, int length)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Agent_Send(pAgent, connId, pBuffer, length);
            }
            else
            {
                return Sdk_x86.HP_Agent_Send(pAgent, connId, pBuffer, length);
            }
        }

        /// <summary>
        /// 发送数据
        /// 用户通过该方法向指定连接发送数据
        /// </summary>
        /// <param name="pAgent"></param>
        /// <param name="connId">连接 ID</param>
        /// <param name="pBuffer">发送数据缓冲区</param>
        /// <param name="length">发送数据长度</param>
        /// <returns></returns>
        public static bool HP_Agent_Send(IntPtr pAgent, IntPtr connId, IntPtr pBuffer, int length)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Agent_Send(pAgent, connId, pBuffer, length);
            }
            else
            {
                return Sdk_x86.HP_Agent_Send(pAgent, connId, pBuffer, length);
            }
        }

        /// <summary>
        /// 发送数据
        /// 用户通过该方法向指定连接发送数据
        /// </summary>
        /// <param name="pAgent"></param>
        /// <param name="connId"></param>
        /// <param name="pBuffer"></param>
        /// <param name="length"></param>
        /// <param name="iOffset">针对pBuffer的偏移</param>
        /// <returns></returns>
        public static bool HP_Agent_SendPart(IntPtr pAgent, IntPtr connId, byte[] pBuffer, int length, int iOffset)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Agent_SendPart(pAgent, connId, pBuffer, length, iOffset);
            }
            else
            {
                return Sdk_x86.HP_Agent_SendPart(pAgent, connId, pBuffer, length, iOffset);
            }
        }

        /// <summary>
        /// 发送数据
        /// 用户通过该方法向指定连接发送数据
        /// </summary>
        /// <param name="pAgent"></param>
        /// <param name="connId"></param>
        /// <param name="pBuffer"></param>
        /// <param name="length"></param>
        /// <param name="iOffset">针对pBuffer的偏移</param>
        /// <returns></returns>
        public static bool HP_Agent_SendPart(IntPtr pAgent, IntPtr connId, IntPtr pBuffer, int length, int iOffset)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Agent_SendPart(pAgent, connId, pBuffer, length, iOffset);
            }
            else
            {
                return Sdk_x86.HP_Agent_SendPart(pAgent, connId, pBuffer, length, iOffset);
            }
        }


        /// <summary>
        /// 发送多组数据
        /// 向指定连接发送多组数据
        /// TCP - 顺序发送所有数据包 
        /// UDP - 把所有数据包组合成一个数据包发送（数据包的总长度不能大于设置的 UDP 包最大长度） 
        /// </summary>
        /// <param name="pAgent"></param>
        /// <param name="connId">连接 ID</param>
        /// <param name="pBuffers">发送缓冲区数组</param>
        /// <param name="iCount">发送缓冲区数目</param>
        /// <returns>TRUE.成功,FALSE	.失败，可通过 Windows API 函数 ::GetLastError() 获取 Windows 错误代码</returns>
        public static bool HP_Agent_SendPackets(IntPtr pAgent, IntPtr connId, WSABUF[] pBuffers, int iCount)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Agent_SendPackets(pAgent, connId, pBuffers, iCount);
            }
            else
            {
                return Sdk_x86.HP_Agent_SendPackets(pAgent, connId, pBuffers, iCount);
            }
        }

        /// <summary>
        /// 断开某个连接
        /// </summary>
        /// <param name="pAgent"></param>
        /// <param name="connId">连接 ID</param>
        /// <param name="bForce">是否强制断开连接</param>
        /// <returns></returns>

        public static bool HP_Agent_Disconnect(IntPtr pAgent, IntPtr connId, bool bForce)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Agent_Disconnect(pAgent, connId, bForce);
            }
            else
            {
                return Sdk_x86.HP_Agent_Disconnect(pAgent, connId, bForce);
            }
        }

        /// <summary>
        /// 断开超过指定时长的连接
        /// </summary>
        /// <param name="pAgent"></param>
        /// <param name="dwPeriod">时长（毫秒）</param>
        /// <param name="bForce">是否强制断开连接</param>
        /// <returns></returns>

        public static bool HP_Agent_DisconnectLongConnections(IntPtr pAgent, uint dwPeriod, bool bForce)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Agent_DisconnectLongConnections(pAgent, dwPeriod, bForce);
            }
            else
            {
                return Sdk_x86.HP_Agent_DisconnectLongConnections(pAgent, dwPeriod, bForce);
            }
        }

        /// <summary>
        /// 断开超过指定时长的静默连接
        /// </summary>
        /// <param name="pServer"></param>
        /// <param name="dwPeriod">时长（毫秒）</param>
        /// <param name="bForce">是否强制断开连接</param>
        /// <returns></returns>

        public static bool HP_Agent_DisconnectSilenceConnections(IntPtr pAgent, uint dwPeriod, bool bForce)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Agent_DisconnectSilenceConnections(pAgent, dwPeriod, bForce);
            }
            else
            {
                return Sdk_x86.HP_Agent_DisconnectSilenceConnections(pAgent, dwPeriod, bForce);
            }
        }

        /******************************************************************************/
        /***************************** Agent 操作方法 *****************************/

        /// <summary>
        ///  名称：发送小文件
        ///  描述：向指定连接发送 4096 KB 以下的小文件
        /// </summary>
        /// <param name="pServer"></param>
        /// <param name="connId">连接 ID</param>
        /// <param name="lpszFileName">文件路径</param>
        /// <param name="pHead">头部附加数据</param>
        /// <param name="pTail">尾部附加数据</param>
        /// <returns>TRUE.成功 FALSE	-- 失败，可通过 Windows API 函数 ::GetLastError() 获取 Windows 错误代码</returns>
        public static bool HP_TcpAgent_SendSmallFile(IntPtr pAgent, IntPtr connId, string lpszFileName, ref WSABUF pHead, ref WSABUF pTail)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_TcpAgent_SendSmallFile(pAgent, connId, lpszFileName, ref  pHead, ref  pTail);
            }
            else
            {
                return Sdk_x86.HP_TcpAgent_SendSmallFile(pAgent, connId, lpszFileName, ref  pHead, ref  pTail);
            }
        }

        /******************************************************************************/
        /***************************** Agent 属性访问方法 *****************************/

        /// <summary>
        /// 设置数据发送策略
        /// </summary>
        /// <param name="pAgent"></param>
        /// <param name="enSendPolicy"></param>

        public static void HP_Agent_SetSendPolicy(IntPtr pAgent, SendPolicy enSendPolicy)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_Agent_SetSendPolicy(pAgent, enSendPolicy);
            }
            else
            {
                Sdk_x86.HP_Agent_SetSendPolicy(pAgent, enSendPolicy);
            }
        }

        /// <summary>
        /// 获取数据发送策略
        /// </summary>
        /// <param name="pAgent"></param>
        /// <returns></returns>

        public static SendPolicy HP_Agent_GetSendPolicy(IntPtr pAgent)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Agent_GetSendPolicy(pAgent);
            }
            else
            {
                return Sdk_x86.HP_Agent_GetSendPolicy(pAgent);
            }
        }

        /// <summary>
        /// 设置连接的附加数据
        /// 是否为连接绑定附加数据或者绑定什么样的数据，均由应用程序自身决定
        /// </summary>
        /// <param name="pAgent"></param>
        /// <param name="connId">连接 ID</param>
        /// <param name="pExtra">数据</param>
        /// <returns>FALSE    -- 失败（无效的连接 ID）</returns>

        public static bool HP_Agent_SetConnectionExtra(IntPtr pAgent, IntPtr connId, IntPtr pExtra)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Agent_SetConnectionExtra(pAgent, connId, pExtra);
            }
            else
            {
                return Sdk_x86.HP_Agent_SetConnectionExtra(pAgent, connId, pExtra);
            }
        }

        /// <summary>
        /// 获取连接的附加数据
        /// 是否为连接绑定附加数据或者绑定什么样的数据，均由应用程序自身决定
        /// </summary>
        /// <param name="pAgent"></param>
        /// <param name="connId"></param>
        /// <param name="pExtra"></param>
        /// <returns></returns>

        public static bool HP_Agent_GetConnectionExtra(IntPtr pAgent, IntPtr connId, ref IntPtr pExtra)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Agent_GetConnectionExtra(pAgent, connId, ref  pExtra);
            }
            else
            {
                return Sdk_x86.HP_Agent_GetConnectionExtra(pAgent, connId, ref  pExtra);
            }
        }

        /// <summary>
        /// 检查通信组件是否已启动
        /// </summary>
        /// <param name="pAgent"></param>
        /// <returns></returns>

        public static bool HP_Agent_HasStarted(IntPtr pAgent)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Agent_HasStarted(pAgent);
            }
            else
            {
                return Sdk_x86.HP_Agent_HasStarted(pAgent);
            }
        }

        /// <summary>
        /// 查看通信组件当前状态
        /// </summary>
        /// <param name="pAgent"></param>
        /// <returns></returns>

        public static ServiceState HP_Agent_GetState(IntPtr pAgent)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Agent_GetState(pAgent);
            }
            else
            {
                return Sdk_x86.HP_Agent_GetState(pAgent);
            }
        }

        /// <summary>
        /// 获取连接数
        /// </summary>
        /// <param name="pAgent"></param>
        /// <returns></returns>

        public static uint HP_Agent_GetConnectionCount(IntPtr pAgent)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Agent_GetConnectionCount(pAgent);
            }
            else
            {
                return Sdk_x86.HP_Agent_GetConnectionCount(pAgent);
            }
        }

        /// <summary>
        /// 获取所有连接的 CONNID
        /// </summary>
        /// <param name="pServer"></param>
        /// <param name="pIDs"></param>
        /// <param name="pdwCount"></param>
        /// <returns></returns>

        public static bool HP_Agent_GetAllConnectionIDs(IntPtr pAgent, IntPtr[] pIDs, ref uint pdwCount)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Agent_GetAllConnectionIDs(pAgent, pIDs, ref  pdwCount);
            }
            else
            {
                return Sdk_x86.HP_Agent_GetAllConnectionIDs(pAgent, pIDs, ref  pdwCount);
            }
        }

        /// <summary>
        /// 获取某个连接时长（毫秒）
        /// </summary>
        /// <param name="pAgent"></param>
        /// <param name="connId"></param>
        /// <param name="pdwPeriod"></param>
        /// <returns></returns>

        public static bool HP_Agent_GetConnectPeriod(IntPtr pAgent, IntPtr connId, ref uint pdwPeriod)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Agent_GetConnectPeriod(pAgent, connId, ref  pdwPeriod);
            }
            else
            {
                return Sdk_x86.HP_Agent_GetConnectPeriod(pAgent, connId, ref  pdwPeriod);
            }
        }

        /// <summary>
        /// 获取某个连接静默时间（毫秒）
        /// </summary>
        /// <param name="pServer"></param>
        /// <param name="connId"></param>
        /// <param name="pdwPeriod"></param>
        /// <returns></returns>

        public static bool HP_Agent_GetSilencePeriod(IntPtr pAgent, IntPtr connId, ref uint pdwPeriod)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Agent_GetSilencePeriod(pAgent, connId, ref  pdwPeriod);
            }
            else
            {
                return Sdk_x86.HP_Agent_GetSilencePeriod(pAgent, connId, ref  pdwPeriod);
            }
        }

        /// <summary>
        /// 获取监听 Socket 的地址信息
        /// </summary>
        /// <param name="pAgent"></param>
        /// <param name="connId"></param>
        /// <param name="lpszAddress"></param>
        /// <param name="piAddressLen"></param>
        /// <param name="pusPort"></param>
        /// <returns></returns>

        public static bool HP_Agent_GetLocalAddress(IntPtr pAgent, IntPtr connId, [MarshalAs(UnmanagedType.LPWStr)] StringBuilder lpszAddress, ref int piAddressLen, ref ushort pusPort)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Agent_GetLocalAddress(pAgent, connId, lpszAddress, ref  piAddressLen, ref  pusPort);
            }
            else
            {
                return Sdk_x86.HP_Agent_GetLocalAddress(pAgent, connId, lpszAddress, ref  piAddressLen, ref  pusPort);
            }
        }

        /// <summary>
        /// 获取某个连接的地址信息
        /// </summary>
        /// <param name="pAgent"></param>
        /// <param name="connId"></param>
        /// <param name="lpszAddress"></param>
        /// <param name="piAddressLen"></param>
        /// <param name="pusPort"></param>
        /// <returns></returns>

        public static bool HP_Agent_GetRemoteAddress(IntPtr pAgent, IntPtr connId, [MarshalAs(UnmanagedType.LPWStr)] StringBuilder lpszAddress, ref int piAddressLen, ref ushort pusPort)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Agent_GetRemoteAddress(pAgent, connId, lpszAddress, ref  piAddressLen, ref  pusPort);
            }
            else
            {
                return Sdk_x86.HP_Agent_GetRemoteAddress(pAgent, connId, lpszAddress, ref  piAddressLen, ref  pusPort);
            }
        }

        /// <summary>
        /// 获取最近一次失败操作的错误代码
        /// </summary>
        /// <param name="pAgent"></param>
        /// <returns></returns>

        public static SocketError HP_Agent_GetLastError(IntPtr pAgent)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Agent_GetLastError(pAgent);
            }
            else
            {
                return Sdk_x86.HP_Agent_GetLastError(pAgent);
            }
        }

        /// <summary>
        /// 获取最近一次失败操作的错误描述
        /// </summary>
        /// <param name="pAgent"></param>
        /// <returns></returns>

        public static IntPtr HP_Agent_GetLastErrorDesc(IntPtr pAgent)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Agent_GetLastErrorDesc(pAgent);
            }
            else
            {
                return Sdk_x86.HP_Agent_GetLastErrorDesc(pAgent);
            }
        }

        /// <summary>
        /// 获取连接中未发出数据的长度
        /// </summary>
        /// <param name="pAgent"></param>
        /// <param name="connId"></param>
        /// <param name="piPending"></param>

        public static bool HP_Agent_GetPendingDataLength(IntPtr pAgent, IntPtr connId, ref int piPending)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Agent_GetPendingDataLength(pAgent, connId, ref  piPending);
            }
            else
            {
                return Sdk_x86.HP_Agent_GetPendingDataLength(pAgent, connId, ref  piPending);
            }
        }

        /// <summary>
        /// 设置 Socket 缓存对象锁定时间（毫秒，在锁定期间该 Socket 缓存对象不能被获取使用）
        /// </summary>
        /// <param name="pAgent"></param>
        /// <param name="dwFreeSocketObjLockTime"></param>

        public static void HP_Agent_SetFreeSocketObjLockTime(IntPtr pAgent, uint dwFreeSocketObjLockTime)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_Agent_SetFreeSocketObjLockTime(pAgent, dwFreeSocketObjLockTime);
            }
            else
            {
                Sdk_x86.HP_Agent_SetFreeSocketObjLockTime(pAgent, dwFreeSocketObjLockTime);
            }
        }

        /// <summary>
        /// 设置 Socket 缓存池大小（通常设置为平均并发连接数量的 1/3 - 1/2）
        /// </summary>
        /// <param name="pAgent"></param>
        /// <param name="dwFreeSocketObjPool"></param>

        public static void HP_Agent_SetFreeSocketObjPool(IntPtr pAgent, uint dwFreeSocketObjPool)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_Agent_SetFreeSocketObjPool(pAgent, dwFreeSocketObjPool);
            }
            else
            {
                Sdk_x86.HP_Agent_SetFreeSocketObjPool(pAgent, dwFreeSocketObjPool);
            }
        }

        /// <summary>
        /// 设置内存块缓存池大小（通常设置为 Socket 缓存池大小的 2 - 3 倍）
        /// </summary>
        /// <param name="pAgent"></param>
        /// <param name="dwFreeBufferObjPool"></param>

        public static void HP_Agent_SetFreeBufferObjPool(IntPtr pAgent, uint dwFreeBufferObjPool)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_Agent_SetFreeBufferObjPool(pAgent, dwFreeBufferObjPool);
            }
            else
            {
                Sdk_x86.HP_Agent_SetFreeBufferObjPool(pAgent, dwFreeBufferObjPool);
            }
        }

        /// <summary>
        /// 设置 Socket 缓存池回收阀值（通常设置为 Socket 缓存池大小的 3 倍）
        /// </summary>
        /// <param name="pAgent"></param>
        /// <param name="dwFreeSocketObjHold"></param>

        public static void HP_Agent_SetFreeSocketObjHold(IntPtr pAgent, uint dwFreeSocketObjHold)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_Agent_SetFreeSocketObjHold(pAgent, dwFreeSocketObjHold);
            }
            else
            {
                Sdk_x86.HP_Agent_SetFreeSocketObjHold(pAgent, dwFreeSocketObjHold);
            }
        }

        /// <summary>
        /// 设置内存块缓存池回收阀值（通常设置为内存块缓存池大小的 3 倍）
        /// </summary>
        /// <param name="pAgent"></param>
        /// <param name="dwFreeBufferObjHold"></param>

        public static void HP_Agent_SetFreeBufferObjHold(IntPtr pAgent, uint dwFreeBufferObjHold)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_Agent_SetFreeBufferObjHold(pAgent, dwFreeBufferObjHold);
            }
            else
            {
                Sdk_x86.HP_Agent_SetFreeBufferObjHold(pAgent, dwFreeBufferObjHold);
            }
        }

        /// <summary>
        /// 设置工作线程数量（通常设置为 2 * CPU + 2）
        /// </summary>
        /// <param name="pAgent"></param>
        /// <param name="dwWorkerThreadCount"></param>

        public static void HP_Agent_SetWorkerThreadCount(IntPtr pAgent, uint dwWorkerThreadCount)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_Agent_SetWorkerThreadCount(pAgent, dwWorkerThreadCount);
            }
            else
            {
                Sdk_x86.HP_Agent_SetWorkerThreadCount(pAgent, dwWorkerThreadCount);
            }
        }

        /// <summary>
        /// 设置是否标记静默时间（设置为 TRUE 时 DisconnectSilenceConnections() 和 GetSilencePeriod() 才有效，默认：FALSE）
        /// </summary>
        /// <param name="pServer"></param>
        /// <param name="bMarkSilence"></param>

        public static void HP_Agent_SetMarkSilence(IntPtr pAgent, bool bMarkSilence)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_Agent_SetMarkSilence(pAgent, bMarkSilence);
            }
            else
            {
                Sdk_x86.HP_Agent_SetMarkSilence(pAgent, bMarkSilence);
            }
        }

        /// <summary>
        /// 获取 Socket 缓存对象锁定时间
        /// </summary>
        /// <param name="pAgent"></param>
        /// <returns></returns>

        public static uint HP_Agent_GetFreeSocketObjLockTime(IntPtr pAgent)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Agent_GetFreeSocketObjLockTime(pAgent);
            }
            else
            {
                return Sdk_x86.HP_Agent_GetFreeSocketObjLockTime(pAgent);
            }
        }

        /// <summary>
        /// 获取 Socket 缓存池大小
        /// </summary>
        /// <param name="pAgent"></param>
        /// <returns></returns>

        public static uint HP_Agent_GetFreeSocketObjPool(IntPtr pAgent)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Agent_GetFreeSocketObjPool(pAgent);
            }
            else
            {
                return Sdk_x86.HP_Agent_GetFreeSocketObjPool(pAgent);
            }
        }

        /// <summary>
        /// 获取内存块缓存池大小
        /// </summary>
        /// <param name="pAgent"></param>
        /// <returns></returns>

        public static uint HP_Agent_GetFreeBufferObjPool(IntPtr pAgent)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Agent_GetFreeBufferObjPool(pAgent);
            }
            else
            {
                return Sdk_x86.HP_Agent_GetFreeBufferObjPool(pAgent);
            }
        }

        /// <summary>
        /// 获取 Socket 缓存池回收阀值
        /// </summary>
        /// <param name="pAgent"></param>
        /// <returns></returns>

        public static uint HP_Agent_GetFreeSocketObjHold(IntPtr pAgent)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Agent_GetFreeSocketObjHold(pAgent);
            }
            else
            {
                return Sdk_x86.HP_Agent_GetFreeSocketObjHold(pAgent);
            }
        }

        /// <summary>
        /// 获取内存块缓存池回收阀值
        /// </summary>
        /// <param name="pAgent"></param>
        /// <returns></returns>

        public static uint HP_Agent_GetFreeBufferObjHold(IntPtr pAgent)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Agent_GetFreeBufferObjHold(pAgent);
            }
            else
            {
                return Sdk_x86.HP_Agent_GetFreeBufferObjHold(pAgent);
            }
        }

        /// <summary>
        /// 获取工作线程数量
        /// </summary>
        /// <param name="pAgent"></param>
        /// <returns></returns>

        public static uint HP_Agent_GetWorkerThreadCount(IntPtr pAgent)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Agent_GetWorkerThreadCount(pAgent);
            }
            else
            {
                return Sdk_x86.HP_Agent_GetWorkerThreadCount(pAgent);
            }
        }

        /// <summary>
        /// 检测是否标记静默时间
        /// </summary>
        /// <param name="pServer"></param>
        /// <returns></returns>

        public static bool HP_Agent_IsMarkSilence(IntPtr pAgent)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_Agent_IsMarkSilence(pAgent);
            }
            else
            {
                return Sdk_x86.HP_Agent_IsMarkSilence(pAgent);
            }
        }

        /**********************************************************************************/
        /***************************** TCP Agent 属性访问方法 *****************************/

        /// <summary>
        /// 置是否启用地址重用机制（默认：不启用）
        /// </summary>
        /// <param name="pAgent"></param>
        /// <param name="bReuseAddress"></param>

        public static void HP_TcpAgent_SetReuseAddress(IntPtr pAgent, bool bReuseAddress)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_TcpAgent_SetReuseAddress(pAgent, bReuseAddress);
            }
            else
            {
                Sdk_x86.HP_TcpAgent_SetReuseAddress(pAgent, bReuseAddress);
            }
        }

        /// <summary>
        /// 检测是否启用地址重用机制
        /// </summary>
        /// <param name="pAgent"></param>
        /// <returns></returns>

        public static bool HP_TcpAgent_IsReuseAddress(IntPtr pAgent)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_TcpAgent_IsReuseAddress(pAgent);
            }
            else
            {
                return Sdk_x86.HP_TcpAgent_IsReuseAddress(pAgent);
            }
        }

        /// <summary>
        /// 设置通信数据缓冲区大小（根据平均通信数据包大小调整设置，通常设置为 1024 的倍数）
        /// </summary>
        /// <param name="pAgent"></param>
        /// <param name="dwSocketBufferSize"></param>

        public static void HP_TcpAgent_SetSocketBufferSize(IntPtr pAgent, uint dwSocketBufferSize)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_TcpAgent_SetSocketBufferSize(pAgent, dwSocketBufferSize);
            }
            else
            {
                Sdk_x86.HP_TcpAgent_SetSocketBufferSize(pAgent, dwSocketBufferSize);
            }
        }

        /// <summary>
        /// 设置心跳包间隔（毫秒，0 则不发送心跳包）
        /// </summary>
        /// <param name="pAgent"></param>
        /// <param name="dwKeepAliveTime"></param>

        public static void HP_TcpAgent_SetKeepAliveTime(IntPtr pAgent, uint dwKeepAliveTime)
        {
            if (Environment.Is64BitProcess)
            {
            }
            else
            {
                Sdk_x86.HP_TcpAgent_SetKeepAliveTime(pAgent, dwKeepAliveTime);
            }
        }

        /// <summary>
        /// 设置心跳确认包检测间隔（毫秒，0 不发送心跳包，如果超过若干次 [默认：WinXP 5 次, Win7 10 次] 检测不到心跳确认包则认为已断线）
        /// </summary>
        /// <param name="pAgent"></param>
        /// <param name="dwKeepAliveInterval"></param>

        public static void HP_TcpAgent_SetKeepAliveInterval(IntPtr pAgent, uint dwKeepAliveInterval)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_TcpAgent_SetKeepAliveInterval(pAgent, dwKeepAliveInterval);
            }
            else
            {
                Sdk_x86.HP_TcpAgent_SetKeepAliveInterval(pAgent, dwKeepAliveInterval);
            }
        }

        /// <summary>
        /// 获取通信数据缓冲区大小
        /// </summary>
        /// <param name="pAgent"></param>
        /// <returns></returns>

        public static uint HP_TcpAgent_GetSocketBufferSize(IntPtr pAgent)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_TcpAgent_GetSocketBufferSize(pAgent);
            }
            else
            {
                return Sdk_x86.HP_TcpAgent_GetSocketBufferSize(pAgent);
            }
        }

        /// <summary>
        /// 获取心跳检查次数
        /// </summary>
        /// <param name="pAgent"></param>
        /// <returns></returns>

        public static uint HP_TcpAgent_GetKeepAliveTime(IntPtr pAgent)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_TcpAgent_GetKeepAliveTime(pAgent);
            }
            else
            {
                return Sdk_x86.HP_TcpAgent_GetKeepAliveTime(pAgent);
            }
        }

        /// <summary>
        /// 获取心跳检查间隔
        /// </summary>
        /// <param name="pAgent"></param>
        /// <returns></returns>

        public static uint HP_TcpAgent_GetKeepAliveInterval(IntPtr pAgent)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_TcpAgent_GetKeepAliveInterval(pAgent);
            }
            else
            {
                return Sdk_x86.HP_TcpAgent_GetKeepAliveInterval(pAgent);
            }
        }

        /***************************************************************************************/
        /***************************** TCP Pull Server 组件操作方法 *****************************/

        /// <summary>
        /// 抓取数据
        /// 用户通过该方法从 Socket 组件中抓取数据
        /// </summary>
        /// <param name="pServer"></param>
        /// <param name="connId">连接 ID</param>
        /// <param name="pBuffer">数据抓取缓冲区</param>
        /// <param name="length">抓取数据长度</param>
        /// <returns></returns>

        public static FetchResult HP_TcpPullServer_Fetch(IntPtr pServer, IntPtr connId, IntPtr pBuffer, int length)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_TcpPullServer_Fetch(pServer, connId, pBuffer, length);
            }
            else
            {
                return Sdk_x86.HP_TcpPullServer_Fetch(pServer, connId, pBuffer, length);
            }
        }

        /// <summary>
        /// 窥探数据（不会移除缓冲区数据） 
        /// 描述：用户通过该方法从 Socket 组件中窥探数据
        /// </summary>
        /// <param name="pServer"></param>
        /// <param name="connId">连接 ID</param>
        /// <param name="pBuffer">窥探缓冲区</param>
        /// <param name="length">窥探数据长度</param>
        /// <returns></returns>

        public static FetchResult HP_TcpPullServer_Peek(IntPtr pServer, IntPtr connId, IntPtr pBuffer, int length)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_TcpPullServer_Peek(pServer, connId, pBuffer, length);
            }
            else
            {
                return Sdk_x86.HP_TcpPullServer_Peek(pServer, connId, pBuffer, length);
            }
        }

        /***************************************************************************************/
        /***************************** TCP Pull Server 属性访问方法 *****************************/

        /***************************************************************************************/
        /***************************** TCP Pull Client 组件操作方法 *****************************/

        /// <summary>
        /// 抓取数据
        /// 用户通过该方法从 Socket 组件中抓取数据
        /// </summary>
        /// <param name="pClient"></param>
        /// <param name="connId">连接 ID</param>
        /// <param name="pBuffer">数据抓取缓冲区</param>
        /// <param name="length">抓取数据长度</param>
        /// <returns></returns>

        public static FetchResult HP_TcpPullClient_Fetch(IntPtr pClient, IntPtr pBuffer, int length)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_TcpPullClient_Fetch(pClient, pBuffer, length);
            }
            else
            {
                return Sdk_x86.HP_TcpPullClient_Fetch(pClient, pBuffer, length);
            }
        }

        /// <summary>
        /// 名称：窥探数据（不会移除缓冲区数据）
        /// 描述：用户通过该方法从 Socket 组件中窥探数据
        /// </summary>
        /// <param name="pClient"></param>
        /// <param name="connId">连接 ID</param>
        /// <param name="pBuffer">数据抓取缓冲区</param>
        /// <param name="length">抓取数据长度</param>
        /// <returns></returns>

        public static FetchResult HP_TcpPullClient_Peek(IntPtr pClient, IntPtr pBuffer, int length)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_TcpPullClient_Peek(pClient, pBuffer, length);
            }
            else
            {
                return Sdk_x86.HP_TcpPullClient_Peek(pClient, pBuffer, length);
            }
        }

        /***************************************************************************************/
        /***************************** TCP Pull Client 属性访问方法 *****************************/

        /***************************************************************************************/
        /***************************** TCP Pull Agent 组件操作方法 *****************************/

        /// <summary>
        /// 抓取数据
        /// 用户通过该方法从 Socket 组件中抓取数据
        /// </summary>
        /// <param name="pAgent"></param>
        /// <param name="connId">连接 ID</param>
        /// <param name="pBuffer">数据抓取缓冲区</param>
        /// <param name="length">抓取数据长度</param>
        /// <returns></returns>

        public static FetchResult HP_TcpPullAgent_Fetch(IntPtr pAgent, IntPtr connId, IntPtr pBuffer, int length)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_TcpPullAgent_Fetch(pAgent, connId, pBuffer, length);
            }
            else
            {
                return Sdk_x86.HP_TcpPullAgent_Fetch(pAgent, connId, pBuffer, length);
            }
        }

        /// <summary>
        /// 名称：窥探数据（不会移除缓冲区数据） 
        /// 描述：用户通过该方法从 Socket 组件中窥探数据
        /// </summary>
        /// <param name="pAgent"></param>
        /// <param name="connId">连接 ID</param>
        /// <param name="pBuffer">数据抓取缓冲区</param>
        /// <param name="length">抓取数据长度</param>
        /// <returns></returns>

        public static FetchResult HP_TcpPullAgent_Peek(IntPtr pAgent, IntPtr connId, IntPtr pBuffer, int length)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_TcpPullAgent_Peek(pAgent, connId, pBuffer, length);
            }
            else
            {
                return Sdk_x86.HP_TcpPullAgent_Peek(pAgent, connId, pBuffer, length);
            }
        }

        /***************************************************************************************/
        /***************************** TCP Pull Agent 属性访问方法 *****************************/

        /***************************************************************************************/

        /***************************************************************************************/
        /***************************** TCP Pack Server 组件操作方法 *****************************/

        /***************************************************************************************/
        /***************************** TCP Pack Server 属性访问方法 *****************************/

        /// <summary>
        /// 设置数据包最大长度（有效数据包最大长度不能超过 524287/0x7FFFF 字节，默认：262144/0x40000）
        /// </summary>
        /// <param name="pServer"></param>
        /// <param name="dwMaxPackSize">有效数据包最大长度不能超过 524287/0x7FFFF 字节，默认：262144/0x40000</param>

        public static void HP_TcpPackServer_SetMaxPackSize(IntPtr pServer, uint dwMaxPackSize)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_TcpPackServer_SetMaxPackSize(pServer, dwMaxPackSize);
            }
            else
            {
                Sdk_x86.HP_TcpPackServer_SetMaxPackSize(pServer, dwMaxPackSize);
            }
        }

        /// <summary>
        /// 设置包头标识（有效包头标识取值范围 0 ~ 8191/0x1FFF，当包头标识为 0 时不校验包头，默认：0）
        /// </summary>
        /// <param name="pServer"></param>
        /// <param name="usPackHeaderFlag">有效包头标识取值范围 0 ~ 8191/0x1FFF，当包头标识为 0 时不校验包头，默认：0</param>

        public static void HP_TcpPackServer_SetPackHeaderFlag(IntPtr pServer, ushort usPackHeaderFlag)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_TcpPackServer_SetPackHeaderFlag(pServer, usPackHeaderFlag);
            }
            else
            {
                Sdk_x86.HP_TcpPackServer_SetPackHeaderFlag(pServer, usPackHeaderFlag);
            }
        }

        /// <summary>
        /// 获取数据包最大长度
        /// </summary>
        /// <param name="pServer"></param>
        /// <returns></returns>

        public static uint HP_TcpPackServer_GetMaxPackSize(IntPtr pServer)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_TcpPackServer_GetMaxPackSize(pServer);
            }
            else
            {
                return Sdk_x86.HP_TcpPackServer_GetMaxPackSize(pServer);
            }
        }

        /// <summary>
        /// 获取包头标识
        /// </summary>
        /// <param name="pServer"></param>
        /// <returns></returns>

        public static ushort HP_TcpPackServer_GetPackHeaderFlag(IntPtr pServer)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_TcpPackServer_GetPackHeaderFlag(pServer);
            }
            else
            {
                return Sdk_x86.HP_TcpPackServer_GetPackHeaderFlag(pServer);
            }
        }
        /***************************************************************************************/
        /***************************** TCP Pack Agent 组件操作方法 *****************************/

        /***************************************************************************************/
        /***************************** TCP Pack Agent 属性访问方法 *****************************/

        /// <summary>
        /// 设置数据包最大长度（有效数据包最大长度不能超过 524287/0x7FFFF 字节，默认：262144/0x40000）
        /// </summary>
        /// <param name="pServer"></param>
        /// <param name="dwMaxPackSize">有效数据包最大长度不能超过 524287/0x7FFFF 字节，默认：262144/0x40000</param>

        public static void HP_TcpPackAgent_SetMaxPackSize(IntPtr pAgent, uint dwMaxPackSize)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_TcpPackAgent_SetMaxPackSize(pAgent, dwMaxPackSize);
            }
            else
            {
                Sdk_x86.HP_TcpPackAgent_SetMaxPackSize(pAgent, dwMaxPackSize);
            }
        }

        /// <summary>
        /// 设置包头标识（有效包头标识取值范围 0 ~ 8191/0x1FFF，当包头标识为 0 时不校验包头，默认：0）
        /// </summary>
        /// <param name="pServer"></param>
        /// <param name="usPackHeaderFlag">有效包头标识取值范围 0 ~ 8191/0x1FFF，当包头标识为 0 时不校验包头，默认：0</param>

        public static void HP_TcpPackAgent_SetPackHeaderFlag(IntPtr pAgent, ushort usPackHeaderFlag)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_TcpPackAgent_SetPackHeaderFlag(pAgent, usPackHeaderFlag);
            }
            else
            {
                Sdk_x86.HP_TcpPackAgent_SetPackHeaderFlag(pAgent, usPackHeaderFlag);
            }
        }

        /// <summary>
        /// 获取数据包最大长度
        /// </summary>
        /// <param name="pServer"></param>
        /// <returns></returns>

        public static uint HP_TcpPackAgent_GetMaxPackSize(IntPtr pAgent)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_TcpPackAgent_GetMaxPackSize(pAgent);
            }
            else
            {
                return Sdk_x86.HP_TcpPackAgent_GetMaxPackSize(pAgent);
            }
        }

        /// <summary>
        /// 获取包头标识
        /// </summary>
        /// <param name="pServer"></param>
        /// <returns></returns>

        public static ushort HP_TcpPackAgent_GetPackHeaderFlag(IntPtr pAgent)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_TcpPackAgent_GetPackHeaderFlag(pAgent);
            }
            else
            {
                return Sdk_x86.HP_TcpPackAgent_GetPackHeaderFlag(pAgent);
            }
        }
        /***************************************************************************************/
        /***************************** TCP Pack Client 组件操作方法 *****************************/

        /***************************************************************************************/
        /***************************** TCP Pack Client 属性访问方法 *****************************/
        /// <summary>
        /// 设置数据包最大长度（有效数据包最大长度不能超过 524287/0x7FFFF 字节，默认：262144/0x40000）
        /// </summary>
        /// <param name="pServer"></param>
        /// <param name="dwMaxPackSize">有效数据包最大长度不能超过 524287/0x7FFFF 字节，默认：262144/0x40000</param>

        public static void HP_TcpPackClient_SetMaxPackSize(IntPtr pClient, uint dwMaxPackSize)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_TcpPackClient_SetMaxPackSize(pClient, dwMaxPackSize);
            }
            else
            {
                Sdk_x86.HP_TcpPackClient_SetMaxPackSize(pClient, dwMaxPackSize);
            }
        }

        /// <summary>
        /// 设置包头标识（有效包头标识取值范围 0 ~ 8191/0x1FFF，当包头标识为 0 时不校验包头，默认：0）
        /// </summary>
        /// <param name="pServer"></param>
        /// <param name="usPackHeaderFlag">有效包头标识取值范围 0 ~ 8191/0x1FFF，当包头标识为 0 时不校验包头，默认：0</param>

        public static void HP_TcpPackClient_SetPackHeaderFlag(IntPtr pClient, ushort usPackHeaderFlag)
        {
            if (Environment.Is64BitProcess)
            {
                Sdk_x64.HP_TcpPackClient_SetPackHeaderFlag(pClient, usPackHeaderFlag);
            }
            else
            {
                Sdk_x86.HP_TcpPackClient_SetPackHeaderFlag(pClient, usPackHeaderFlag);
            }
        }

        /// <summary>
        /// 获取数据包最大长度
        /// </summary>
        /// <param name="pServer"></param>
        /// <returns></returns>

        public static uint HP_TcpPackClient_GetMaxPackSize(IntPtr pClient)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_TcpPackClient_GetMaxPackSize(pClient);
            }
            else
            {
                return Sdk_x86.HP_TcpPackClient_GetMaxPackSize(pClient);
            }
        }

        /// <summary>
        /// 获取包头标识
        /// </summary>
        /// <param name="pServer"></param>
        /// <returns></returns>

        public static ushort HP_TcpPackClient_GetPackHeaderFlag(IntPtr pClient)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_TcpPackClient_GetPackHeaderFlag(pClient);
            }
            else
            {
                return Sdk_x86.HP_TcpPackClient_GetPackHeaderFlag(pClient);
            }
        }
        /***************************************************************************************/
        /*************************************** 其它方法 ***************************************/

        /// <summary>
        /// 获取错误描述文本
        /// </summary>
        /// <param name="enCode"></param>
        /// <returns></returns>

        public static IntPtr HP_GetSocketErrorDesc(SocketError enCode)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.HP_GetSocketErrorDesc(enCode);
            }
            else
            {
                return Sdk_x86.HP_GetSocketErrorDesc(enCode);
            }
        }

        /// <summary>
        /// 调用系统的 ::GetLastError() 方法获取系统错误代码
        /// </summary>
        /// <returns></returns>
        public static int SYS_GetLastError()
        {
            return Marshal.GetLastWin32Error();
        }

        /// <summary>
        /// 调用系统的 ::WSAGetLastError() 方法获取通信错误代码
        /// </summary>
        /// <returns></returns>
        public static int SYS_WSAGetLastError()
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.SYS_WSAGetLastError();
            }
            else
            {
                return Sdk_x86.SYS_WSAGetLastError();
            }
        }

        /// <summary>
        /// 调用系统的 setsockopt()
        /// </summary>
        /// <param name="sock"></param>
        /// <param name="level"></param>
        /// <param name="name"></param>
        /// <param name="val"></param>
        /// <param name="len"></param>
        /// <returns></returns>
        public static int SYS_SetSocketOption(IntPtr sock, int level, int name, IntPtr val, int len)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.SYS_SetSocketOption(sock, level, name, val, len);
            }
            else
            {
                return Sdk_x86.SYS_SetSocketOption(sock, level, name, val, len);
            }
        }

        /// <summary>
        /// 调用系统的 getsockopt()
        /// </summary>
        /// <param name="sock"></param>
        /// <param name="level"></param>
        /// <param name="name"></param>
        /// <param name="val"></param>
        /// <param name="len"></param>
        /// <returns></returns>
        public static int SYS_GetSocketOption(IntPtr sock, int level, int name, IntPtr val, ref int len)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.SYS_GetSocketOption(sock, level, name, val, ref  len);
            }
            else
            {
                return Sdk_x86.SYS_GetSocketOption(sock, level, name, val, ref  len);
            }
        }

        /// <summary>
        /// 调用系统的 ioctlsocket()
        /// </summary>
        /// <param name="sock"></param>
        /// <param name="cmd"></param>
        /// <param name="arg"></param>
        /// <returns></returns>
        public static int SYS_IoctlSocket(IntPtr sock, long cmd, IntPtr arg)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.SYS_IoctlSocket(sock, cmd, arg);
            }
            else
            {
                return Sdk_x86.SYS_IoctlSocket(sock, cmd, arg);
            }
        }

        /// <summary>
        /// 调用系统的 ::WSAIoctl()
        /// </summary>
        /// <param name="sock"></param>
        /// <param name="dwIoControlCode"></param>
        /// <param name="lpvInBuffer"></param>
        /// <param name="cbInBuffer"></param>
        /// <param name="lpvOutBuffer"></param>
        /// <param name="cbOutBuffer"></param>
        /// <param name="lpcbBytesReturned"></param>
        /// <returns></returns>
        public static int SYS_WSAIoctl(IntPtr sock, uint dwIoControlCode, IntPtr lpvInBuffer, uint cbInBuffer,
                                              IntPtr lpvOutBuffer, uint cbOutBuffer, uint lpcbBytesReturned)
        {
            if (Environment.Is64BitProcess)
            {
                return Sdk_x64.SYS_WSAIoctl(sock, dwIoControlCode, lpvInBuffer, cbInBuffer,
                                               lpvOutBuffer, cbOutBuffer, lpcbBytesReturned);
            }
            else
            {
                return Sdk_x86.SYS_WSAIoctl(sock, dwIoControlCode, lpvInBuffer, cbInBuffer,
                                               lpvOutBuffer, cbOutBuffer, lpcbBytesReturned);
            }
        }


        #region 3、方法三 (可逆加密)
        const string KEY_64 = "VavicApp";//注意了，是8个字符，64位
        const string IV_64 = "VavicApp";
        /// <summary>
        /// 加密
        /// </summary>
        /// <param name="data">待加密的数据字符</param>
        /// <returns></returns>
        public static string Encode(string data)
        {
            byte[] byKey = System.Text.ASCIIEncoding.ASCII.GetBytes(KEY_64);
            byte[] byIV = System.Text.ASCIIEncoding.ASCII.GetBytes(IV_64);

            DESCryptoServiceProvider cryptoProvider = new DESCryptoServiceProvider();
            int i = cryptoProvider.KeySize;
            MemoryStream ms = new MemoryStream();
            CryptoStream cst = new CryptoStream(ms, cryptoProvider.CreateEncryptor(byKey, byIV), CryptoStreamMode.Write);

            StreamWriter sw = new StreamWriter(cst);
            sw.Write(data);
            sw.Flush();
            cst.FlushFinalBlock();
            sw.Flush();
            return Convert.ToBase64String(ms.GetBuffer(), 0, (int)ms.Length);
        }
        /// <summary>
        /// 解密
        /// </summary>
        /// <param name="data">待解密的数据字符</param>
        /// <returns></returns>
        public static string Decode(string data)
        {
            try
            {
                byte[] byKey = System.Text.ASCIIEncoding.ASCII.GetBytes(KEY_64);
                byte[] byIV = System.Text.ASCIIEncoding.ASCII.GetBytes(IV_64);

                byte[] byEnc;
                try
                {
                    byEnc = Convert.FromBase64String(data);
                }
                catch
                {
                    return data;
                }

                DESCryptoServiceProvider cryptoProvider = new DESCryptoServiceProvider();
                MemoryStream ms = new MemoryStream(byEnc);
                CryptoStream cst = new CryptoStream(ms, cryptoProvider.CreateDecryptor(byKey, byIV), CryptoStreamMode.Read);
                StreamReader sr = new StreamReader(cst);
                return sr.ReadToEnd();
            }
            catch
            {
                return data;
            }
        }
        #endregion
        #region  GZipStream 压缩/解压
        /// <summary>
        /// byte[]压缩
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public static byte[] Compress(byte[] data)
        {
            try
            {
                MemoryStream ms = new MemoryStream();
                System.IO.Compression.GZipStream zip = new System.IO.Compression.GZipStream(ms, System.IO.Compression.CompressionMode.Compress, true);
                zip.Write(data, 0, data.Length);
                zip.Close();
                byte[] buffer = new byte[ms.Length];
                ms.Position = 0;
                ms.Read(buffer, 0, buffer.Length);
                ms.Close();
                return buffer;

            }
            catch (Exception e)
            {
                throw new Exception(e.Message);
            }
        }

        /// <summary>
        /// byte[]解压缩
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public static byte[] Decompress(byte[] data)
        {
            try
            {
                MemoryStream ms = new MemoryStream(data);
                System.IO.Compression.GZipStream zip = new System.IO.Compression.GZipStream(ms, System.IO.Compression.CompressionMode.Decompress, true);
                MemoryStream msreader = new MemoryStream();
                byte[] buffer = new byte[0x1000];
                while (true)
                {
                    int reader = zip.Read(buffer, 0, buffer.Length);
                    if (reader <= 0)
                    {
                        break;
                    }
                    msreader.Write(buffer, 0, reader);
                }
                zip.Close();
                ms.Close();
                msreader.Position = 0;
                buffer = msreader.ToArray();
                msreader.Close();
                return buffer;
            }
            catch (Exception e)
            {
                throw new Exception(e.Message);
            }
        }
        /// <summary>
        /// 压缩字符串
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static string CompressString(string str)
        {
            string compressString = "";
            byte[] compressBeforeByte = Encoding.GetEncoding("UTF-8").GetBytes(str);
            byte[] compressAfterByte = Compress(compressBeforeByte);
            //compressString = Encoding.GetEncoding("UTF-8").GetString(compressAfterByte);  
            compressString = Convert.ToBase64String(compressAfterByte);
            return compressString;
        }
        /// <summary>
        /// 解压字符串
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static string DecompressString(string str)
        {
            string compressString = "";
            //byte[] compressBeforeByte = Encoding.GetEncoding("UTF-8").GetBytes(str);  
            byte[] compressBeforeByte = Convert.FromBase64String(str);
            byte[] compressAfterByte = Decompress(compressBeforeByte);
            compressString = Encoding.GetEncoding("UTF-8").GetString(compressAfterByte);
            return compressString;
        }

        #endregion

        #region  SharpZipLib 压缩/解压

        /// <summary>
        /// 压缩
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public static string Compress(string input)
        {
            string result = string.Empty;
            byte[] buffer = Encoding.UTF8.GetBytes(input);
            using (MemoryStream outputStream = new MemoryStream())
            {
                using (ICSharpCode.SharpZipLib.BZip2.BZip2OutputStream zipStream = new ICSharpCode.SharpZipLib.BZip2.BZip2OutputStream(outputStream))
                {
                    zipStream.Write(buffer, 0, buffer.Length);
                    zipStream.Close();
                }
                return Convert.ToBase64String(outputStream.ToArray());
            }
        }
        /// <summary>
        /// 解压缩
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public static string Decompress(string input)
        {
            string result = string.Empty;
            byte[] buffer = Convert.FromBase64String(input);
            using (Stream inputStream = new MemoryStream(buffer))
            {
                ICSharpCode.SharpZipLib.BZip2.BZip2InputStream zipStream = new ICSharpCode.SharpZipLib.BZip2.BZip2InputStream(inputStream);

                using (StreamReader reader = new StreamReader(zipStream, Encoding.UTF8))
                {
                    //输出
                    result = reader.ReadToEnd();
                }
            }

            return result;
        }

        #endregion

    }
}