c#通讯实例，socket的select模型，多通道及文件生成

【实例简介】c#通讯实例，socket的select模型，多通道及文件生成
【实例截图】
【核心代码】
using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Net;
using System.Net.Sockets;
using System.Runtime.InteropServices;
using SGAI.GrindCom.Proxy.Utilities;
using System.Reflection;

namespace SGAI.GrindCom.Proxy.Net
{
    public class TcpClientChannel : TcpChannelBase
    {
        #region 字段

        public event EventHandler<SocketArgs> Errormanager;

        #endregion

        #region 属性

        public sendTelegramStr SendTelegramStr
        {
            get { return SendtelegramStr; }
            set { SendtelegramStr = value; }
        }

        public sendTelegramByte SendTelegramByte
        {
            get { return SendtelegramByte; }
            set { SendtelegramByte = value; }
        }

        public sendErrorMsg SendErrorMsg
        {
            get { return SendErrormsg; }
            set { SendErrormsg = value; }
        }


        #endregion

        #region 构造函数

        public TcpClientChannel(AddressFamily addressFamily, System.Net.Sockets.SocketType socketType, ProtocolType protocolType, int length, int reconnecttime, int healthtime)
            : base(addressFamily, socketType, protocolType, length)
        {
            this.error_occurred = false;
            this.reconnecttime = reconnecttime;
            this.healthtime = healthtime;
        }

        #endregion

        #region 接口函数

        public override void OnRead()
        {
            SyncReceiveData();
        }

        public override void OnSend()
        {
            if (socketState == SocketState.Disconnected || socketState == SocketState.WaitingForConnect)
            {
                socketState = SocketState.Connected;
                OnLastOperCompeleted();
                //Logger.WriteInfo("This ClientSocket success ");
            }
            else
            {
            }
        }

        public override void OnError()
        {
            ErrorStartTime = DateTime.Now;
            this.socketState = SocketState.Disconnected;
            //Logger.WriteInfo("This ClientSocket Can not connect!");
        }

        #endregion

        #region 同步处理

        #region 同步处理接口函数
        public override bool SyncStart(IpEndPoint iep,ref string msg)
        {
            return OnSyncStart(iep,ref msg);
        }

        public override bool SyncDataSend(byte[] data,ref string msg)
        {
            bool ret = false;
            ret = DataSend(data,ref msg);
            return ret;
        }

        private bool DataSend(byte[] data,ref string msg)
        {
            bool ret = false;
            if (socketState == SocketState.Connected)
            {
                try
                {
                    base.Send(data);
                    OnLastOperCompeleted();
                    ret = true;
                    msg = "发送数据成功！";//send data ok !
                }
                catch (ArgumentNullException ae)
                {
                    msg = ae.Message;
                    ret = false;
                }
                catch (SocketException se)
                {
                    if (se.NativeErrorCode.Equals(10035))
                    {
                        socketState = SocketState.WritingData;

                        ret = true;
                    }
                    else
                    {
                        msg = se.Message;
                        OnSendError();
                        ret = false;
                    }
                }
                catch (ObjectDisposedException)
                {
                    msg = "客户端已经关闭！";//ClientSocket is already close
                    ret = false;
                }
            }
            else
            {
                ret = false;
            }
            return ret;
        }

        public override void SyncReceiveData()
        {
            OnReceiveData();
        }

        private void OnReceiveData()
        {
            int curRcv = 0;
            string msg = null;
            try
            {
                curRcv = this.Receive(Buffer, 0, Buffer.Length, SocketFlags.None);

                if (curRcv > 1)
                {
                    this.OnLastOperCompeleted();
                    OnReceivedDataCompleted();
                    //this.socketState = SocketState.Connected;
                }
                else
                {
                    if (curRcv == 0)
                    {
                        msg = "远短可能已经关闭或发送的为错误数据！";//remote socket maybe close or send error data !
                        OnReceiveError(msg);
                    }
                }
            }
            catch (ObjectDisposedException)
            {
                msg = "工作套接字已经关闭！";//the work socket is already close !
                OnReceiveError(msg);
            }
            catch (SocketException e)
            {
                if (e.NativeErrorCode == 10054)
                {
                    msg = "远端连接已经断开多压根就没连接！";//the remote socket connection maybe already break or never established !
                    OnReceiveError(msg);
                }
                else
                {
                    msg = e.Message;
                    OnReceiveError(msg);
                }
            }
        }

        private void OnReceivedDataCompleted()
        {
            try
            {
                OnSendTelegram(this.Buffer);
            }
            catch (Exception de)
            {
                ErrorMsgManager(de.Message);
            }
        }

        #endregion

        #endregion

        #region 内部同步处理函数

        protected bool OnSyncStart(IpEndPoint iep,ref string msg)
        {
            this.Blocking = false; //设置非阻塞状态，以便事件通知的效率  
            bool ret = true;
            try
            {
                base.Connect(iep);
                ret = true;
            }
            catch (ArgumentNullException ae)
            {
                msg = ae.Message;
                ret = false;
            }
            catch (SocketException se)
            {
                if (se.NativeErrorCode == WSAEWOULDBLOCK)
                {
                    msg = "Connect Operation is pending";
                    this.socketState = SocketState.WaitingForConnect;
                    ret = true;
                }
                else
                {
                    msg = se.Message;
                    ret = false;
                }
            }
            catch (ObjectDisposedException)
            {
                msg = "this ClientSocket is Close";
                ret = false;
            }
            return ret;
        }

        protected override void OnStop()
        {
            string msg = null;
            try
            {
                if (this != null)
                {
                    if (this.Connected)
                    {
                        this.Shutdown(SocketShutdown.Both);
                        this.Disconnect(false);
                    }

                    this.Close();
                }

            }
            catch (ObjectDisposedException)
            {
                msg = "this Client socket is already close !";
                ErrorMsgManager(msg);
            }
        }

        protected override void OnLastOperCompeleted()
        {
            LastActiveTime = DateTime.Now;
        }

        #endregion

        #region 通用处理

        #region 通用处理接口函数

        public override void Stop()
        {
            OnStop();
        }

        public override bool SetSocketOption()
        {
            bool ret_value = true;
            try
            {
                this.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.KeepAlive, 1);
                //this.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, 1);

                tcp_keepalive ka;
                ka.onoff = 1;
                ka.keepalivetime = 5000;
                ka.keepaliveinterval = 3000;
                byte[] IN = new byte[12];
                byte[] OUT = new byte[12];

                StructToBytes(ka, IN, typeof(tcp_keepalive));

                int ret_code = this.IOControl(IOControlCode.KeepAliveValues, IN, OUT);
                if (ret_code != 0)
                    ret_value = false;

            }
            catch (SocketException)
            {
                ret_value = false;
            }
            return ret_value;
        }

        public override bool SendCheck()
        {
            DateTime now;
            TimeSpan span;
            now = DateTime.Now;
            string msg = null;
            bool ret = false;

            if (socketState == SocketState.Disconnected)
            {
                span = now - ErrorStartTime;
                if (span.TotalMilliseconds >= this.ReconnectTime)
                {
                    ret = this.OnSyncStart(EndPoint,ref msg);
                    if (!ret)
                    {
                        ErrorMsgManager(msg);
                    }
                }
                else
                {
                }
            }
            else
            {
                if (socketState == SocketState.WaitingForConnect || socketState == SocketState.WritingData)
                {
                    ret = true;
                }
                else
                {
                    if (socketState != SocketState.Error)
                    {
                        span = now - LastActiveTime;
                        if (span.TotalMilliseconds >= this.HealthTime)
                        {
                            try
                            {
                                byte[] tmp = new byte[1];
                                Send(tmp, 0, 0);
                                OnLastOperCompeleted();
                            }
                            catch (SocketException e)
                            {
                                if (e.NativeErrorCode.Equals(10035))
                                {
                                }
                                else
                                {
                                    ErrorMsgManager(e.Message);
                                    OnSendError();
                                }
                            }
                        }
                        else
                        {
                        }
                    }
                    else
                    {
                    }
                }
                ret = true;
            }
            return ret;
        }

        public override bool ReadCheck()
        {
            bool ret = false;
            if (this.socketState != SocketState.Disconnected && this.socketState != SocketState.Error)
            {
                ret = true;
            }
            return ret;
        }

        public override bool ErrorCheck()
        {
            bool ret = false;

            if (socketState == SocketState.WaitingForConnect)
            {
                ret = true;
            }

            return ret;
        }

        protected virtual bool OnSendTelegram(byte[] buffer)
        {
            bool ret = false;
            string msg = null;
            if (isStr)
            {
                if (SendtelegramStr != null)
                {
                    msg = Encoding.ASCII.GetString(buffer);
                    ret = SendtelegramStr(msg);
                }
            }
            else
            {
                if (SendtelegramByte != null)
                {
                    ret = SendtelegramByte(buffer);
                }
            }
            
            return ret;
        }

        #endregion

        #region 内部通用处理函数

        private object BytesToStruct(byte[] bytes, Type strcutType)
        {

            int size = Marshal.SizeOf(strcutType);
            IntPtr buffer = Marshal.AllocHGlobal(size);
            try
            {
                Marshal.Copy(bytes, 0, buffer, size);
                object rVar = Marshal.PtrToStructure(buffer, strcutType);
                return rVar;
            }
            finally
            {
                Marshal.FreeHGlobal(buffer);
            }
        }

        private void StructToBytes(tcp_keepalive ka, byte[] bytes, Type structType)
        {
            int size = Marshal.SizeOf(structType);
            IntPtr buffer = Marshal.AllocHGlobal(size);
            try
            {
                Marshal.StructureToPtr(ka, buffer, false);
                Marshal.Copy(buffer, bytes, 0, size);
            }
            catch (ArgumentException ae)
            {
                ErrorMsgManager(ae.Message);
            }
            finally
            {
                Marshal.FreeHGlobal(buffer);
            }
        }

        #endregion

        #endregion

        #region 异常处理

        protected override void OnReceiveError(string msg)
        {
            ErrorMsgManager(msg);
            RaiseDisconnectedEvent();
        }

        protected override void OnSendError()
        {
            RaiseDisconnectedEvent();
        }

        protected override void RaiseErrorEvent(System.Exception x)
        {
            ErrorMsgManager(x.Message);
            OnSendError();
        }

        internal protected virtual void RaiseDisconnectedEvent()
        {
            EventHandler<SocketArgs> temp;
            temp = Errormanager;
            if (temp != null)
            {
                temp(this, new SocketArgs(Name));
            }
        }

        private void ErrorMsgManager(string msg)
        {
            if (this.SendErrormsg != null)
            {
                this.SendErrormsg(msg);
            }
        }

        #endregion
    }
}