MyEasyClient简单使用

    public class MyEasyClient
    {
        EasyClient<MyPackageInfo> client = null;
        public async void Connect(string ip, int prot)
        {
            client = new EasyClient<MyPackageInfo>();
            client.Initialize(new MyReceiveFilter());
            client.Connected += OnClientConnected;
            client.NewPackageReceived += OnPackageReceived;
            client.Error += OnClientError;
            client.Closed += OnClientClosed;
            var connected = await client.ConnectAsync(new IPEndPoint(IPAddress.Parse(ip), prot));
            if (connected)
            {
                //连接成功
            }
            else
            {
                //连接失败
            }
        }

        private void DebugLog(string log)
        {
            System.Diagnostics.Debug.WriteLine("MyEasyClient:" + log);
        }

        private void OnPackageReceived(object sender, PackageEventArgs<MyPackageInfo> e)
        {
            DebugLog("收到数据：" + e.Package.Body);
            if (OnRecive != null)
            {
                OnRecive(e.Package.Body);
            }
        }

        private void OnClientConnected(object sender, EventArgs e)
        {
            DebugLog("已连接到服务器...");
        }

        private void OnClientClosed(object sender, EventArgs e)
        {
            DebugLog("连接已断开...");
        }

        private void OnClientError(object sender, SuperSocket.ClientEngine.ErrorEventArgs e)
        {
            DebugLog("客户端错误：" + e.Exception.Message);
        }

        public bool IsConnected()
        {
            if (client != null && client.IsConnected == true)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        /// <summary>
        /// 发送数据
        /// </summary>
        public void Send(byte[] data)
        {
            if (IsConnected())
            {
                client.Send(data);
            }
        }
    }

  public class MyReceiveFilter : FixedHeaderReceiveFilter<MyPackageInfo>
    { 
        public MyReceiveFilter()
            : base(12)
        {

        }
        protected override int GetBodyLengthFromHeader(IBufferStream bufferStream, int length)
        {
            ArraySegment<byte> buffers = bufferStream.Buffers[0];
            byte[] array = buffers.ToArray();

            DataHead head = ByteHelper.BytesToStruct<DataHead>(array);

            return (int)head.Length;
        }
        public override MyPackageInfo ResolvePackage(IBufferStream bufferStream)
        {
            //第三个参数用0,1都可以
            byte[] header = bufferStream.Buffers[0].ToArray();
            byte[] bodyBuffer = bufferStream.Buffers[1].ToArray();
            byte[] allBuffer = bufferStream.Buffers[0].Array.CloneRange(0, (int)bufferStream.Length);
            return new MyPackageInfo(header, bodyBuffer);
        }
    }

    public class MyReceiveFilter1 : IReceiveFilter<MyPackageInfo1>
    {
        MyPackageInfo1 IReceiveFilter<MyPackageInfo1>.Filter(BufferList data, out int rest)
        {
            rest = 0;
            if (data.Total > 0)
                return new MyPackageInfo1(data.Last.CloneRange(data.Last.Offset, data.Last.Count));

            return default(MyPackageInfo1);
        }

        public void Reset()
        {
            NextReceiveFilter = null;
            State = FilterState.Normal;
        }

        public IReceiveFilter<MyPackageInfo1> NextReceiveFilter { get; protected set; }
        public FilterState State { get; protected set; }
    }

  /// <summary>
    /// 有协议头
    /// </summary>
    public class MyPackageInfo : IPackageInfo
    {
        public MyPackageInfo(byte[] header, byte[] bodyBuffer)
        {
            Header = header;
            Data = bodyBuffer;
        }
        /// <summary>
        /// 服务器返回的字节数据头部
        /// </summary>
        public byte[] Header { get; set; }

        /// <summary>
        /// 服务器返回的字节数据
        /// </summary>
        public byte[] Data { get; set; }


        /// <summary>
        /// 服务器返回的字符串数据
        /// </summary>
        public string Body
        {
            get
            {
                return Encoding.UTF8.GetString(Data);
            }
        }
    }


    /// <summary>
    /// 无协议头
    /// </summary>
    public class MyPackageInfo1 : IPackageInfo
    {
        public MyPackageInfo1( byte[] bodyBuffer)
        {
            Data = bodyBuffer;
        }

        /// <summary>
        /// 服务器返回的字节数据
        /// </summary>
        public byte[] Data { get; set; }
        /// <summary>
        /// 服务器返回的字符串数据
        /// </summary>
        public string Body
        {
            get
            {
                return Encoding.UTF8.GetString(Data);
            }
        }
    }