HEGII.ss.mes.plc/Curtain.Net.Sockets/PLC/PLCSocket.cs


using System;
using System.Net.Sockets;

using Curtain.Net.Sockets.PLC.ThreadLock;

namespace Curtain.Net.Sockets.PLC
{
    /// <summary>
    /// Socket 通信基类
    /// </summary>
    public abstract class PLCSocket : IDisposable
    {
        #region 变量
        #endregion

        #region 属性
        /// <summary>
        /// 销毁状态
        /// </summary>
        public bool IsDispose
        {
            get;
            protected set;
        }

        /// <summary>
        /// 通信用Socket
        /// </summary>
        public Socket Socket
        {
            get; protected set;
        }

        /// <summary>
        /// 线程锁
        /// </summary>
        public IThreadLock ThreadLock
        {
            get;
            protected set;
        } = new ReaderWriterThreadLock();
        #endregion

        #region 构造
        /// <summary>
        /// Socket 通信基类
        /// </summary>
        public PLCSocket()
        {
        }

        /// <summary>
        /// Socket 通信基类
        /// </summary>
        /// <param name="socket">Socket</param>
        public PLCSocket(Socket socket)
        {
            this.Socket = socket;
        }
        #endregion

        #region 连接&关闭
        /// <summary>
        /// 创建Socket
        /// </summary>
        /// <param name="addressFamily"></param>
        /// <param name="socketType"></param>
        /// <param name="protocolType"></param>
        public virtual void CreateSocket(AddressFamily addressFamily, SocketType socketType, ProtocolType protocolType)
        {
            if (Socket != null)
            {
                try
                {
                    //if (Socket.Connected)
                    //{
                    //    Socket.Close();
                    //}
                    Socket.Dispose();
                }
                catch
                {
                }
            }
            if (IsDispose)
            {
                IsDispose = false;
            }
            if (ThreadLock == null)
            {
                ThreadLock = new ReaderWriterThreadLock();
            }
            Socket = new Socket(addressFamily, socketType, protocolType);
        }

        /// <summary>
        /// 创建Socket
        /// </summary>
        public virtual void CreateSocket()
        {
            CreateSocket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        }

        /// <summary>
        /// 连接Socket
        /// </summary>
        /// <param name="host"></param>
        /// <param name="port"></param>
        public virtual void Connect(string host, int port)
        {
            if (this.Socket == null)
            {
                this.CreateSocket();
            }
            //else
            //{
            //    // 刷新 Connected 状态（服务端关闭连接时，客户端 Connected=true）。
            //    try
            //    {
            //        bool b = Socket.EnableBroadcast;
            //    }
            //    catch
            //    {
            //    }
            //}
            if (!this.Socket.Connected)
            {
                //try
                //{
                //    this.Socket.Connect(host, port);
                //    this.OnSocketConnect();
                //}
                ////catch (InvalidOperationException ex)
                //catch //(Exception ex)
                //{
                //    this.Close();
                //    this.CreateSocket();
                //    this.Socket.Connect(host, port);
                //    this.OnSocketConnect();
                //}

                this.Socket.Connect(host, port);
                this.OnSocketConnect();
            }
        }

        /// <summary>
        /// Socket连接后PLC初始化
        /// </summary>
        public virtual void OnSocketConnect()
        {
        }

        /// <summary>
        /// 断开连接
        /// </summary>
        public virtual void Disconnect()
        {
            if (this.Socket == null)
            {
                return;
            }

            if (this.Socket.Connected)
            {
                try
                {
                    this.Socket.Disconnect(true);
                }
                catch //(Exception ex)
                {
                    this.Close();
                    this.Socket = null;
                }
            }
        }

        /// <summary>
        /// 关闭Socket
        /// </summary>
        /// <returns></returns>
        public virtual bool Close()
        {
            if (Socket == null)
            {
                return true;
            }

            try
            {
                Socket.Close();
                Socket = null;
            }
            catch //(Exception ex)
            {
                return false;
            }
            return true;
        }

        /// <summary>
        /// 销毁
        /// </summary>
        public virtual void Dispose()
        {
            try
            {
                Socket?.Dispose();
                Socket = null;
                ThreadLock.Dispose();
                ThreadLock = null;
            }
            catch
            {
            }
            finally
            {
                IsDispose = true;
            }
        }
        #endregion

        #region Send
        /// <summary>
        /// 发送
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        internal protected virtual PLCResult Send(byte[] data)
        {
            PLCResult plcResult = new PLCResult();
            if (data == null || data.Length == 0)
            {
                plcResult.Successed = false;
                plcResult.Message = "c:send no command";
                return plcResult;
            }

            if (Socket == null)
            {
                plcResult.Successed = false;
                plcResult.Message = "c:send no socket";
                return plcResult;
            }

            if (!Socket.Connected)
            {
                plcResult.Successed = false;
                plcResult.Message = "c:send no connected";
                return plcResult;
            }

            try
            {
                //plcResult.Result = Socket.Send(data);
                Socket.Send(data);
            }
            catch (Exception ex)
            {
                plcResult.Successed = false;
                plcResult.Message = "c:send " + ex.Message;
                plcResult.MessageDetail = ex.ToString();
                Socket?.Close();
                Socket = null;
            }

            return plcResult;
        }

        /// <summary>
        /// 异步发送
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        internal protected virtual PLCResult BeginSend(byte[] data)
        {
            PLCResult plcResult = new PLCResult();
            if (data == null || data.Length == 0)
            {
                plcResult.Successed = false;
                plcResult.Message = "c:begin send no command";
                return plcResult;
            }

            if (Socket == null)
            {
                plcResult.Successed = false;
                plcResult.Message = "c:begin send no socket";
                return plcResult;
            }

            if (!Socket.Connected)
            {
                plcResult.Successed = false;
                plcResult.Message = "c:begin send no connected";
                return plcResult;
            }

            SocketAsyncState sas = new SocketAsyncState();
            try
            {
                sas.Data = data;
                sas.Size = data.Length;
                sas.Result = plcResult;
                Socket.BeginSend(sas.Data, sas.Offset, sas.Size, SocketFlags.None, SendCallBack, sas);
            }
            catch (Exception ex)
            {
                plcResult.Successed = false;
                plcResult.Message = "c:begin send " + ex.Message;
                plcResult.MessageDetail = ex.ToString();
                sas?.Close();
                sas = null;
                Socket?.Close();
                Socket = null;
            }

            sas?.WaitOne();
            sas?.Close();
            sas = null;

            return plcResult;
        }

        /// <summary>
        /// 发送结束
        /// </summary>
        /// <param name="iar"></param>
        private void SendCallBack(IAsyncResult iar)
        {
            if (iar.AsyncState is SocketAsyncState sas)
            {
                try
                {
                    sas.Offset += Socket.EndSend(iar);
                    if (sas.Offset < sas.Size)
                    {
                        Socket.BeginSend(sas.Data, sas.Offset, sas.Size - sas.Offset, SocketFlags.None, SendCallBack, iar);
                    }
                    else
                    {
                        sas.Set();
                    }
                }
                catch (Exception ex)
                {
                    sas.Result.Successed = false;
                    sas.Result.Message = "c:send callback " + ex.Message;
                    sas.Result.MessageDetail = ex.ToString();
                    Socket.Close();
                    Socket = null;
                    sas.Set();
                }
            }
        }
        #endregion

        #region Receive
        /// <summary>
        /// 接收
        /// </summary>
        /// <param name="length"></param>
        /// <returns></returns>
        protected virtual PLCResult<byte[]> Receive(int length)
        {
            PLCResult<byte[]> plcResult = new PLCResult<byte[]>(new byte[length]);
            if (length == 0)
            {
                plcResult.Successed = false;
                plcResult.Message = "c:receive no length";
                return plcResult;
            }

            if (Socket == null)
            {
                plcResult.Successed = false;
                plcResult.Message = "c:receive no socket";
                return plcResult;
            }

            if (!Socket.Connected)
            {
                plcResult.Successed = false;
                plcResult.Message = "c:receive no connected";
                return plcResult;
            }

            try
            {
                //plcResult.Result = Socket.Receive(plcResult.Data);
                //Socket.Receive(plcResult.Data);
                Socket.Receive(plcResult.Data, 0, length, SocketFlags.None);
            }
            catch (Exception ex)
            {
                plcResult.Successed = false;
                plcResult.Message = "c:receive " + ex.Message;
                plcResult.MessageDetail = ex.ToString();
                Socket?.Close();
                Socket = null;
            }

            return plcResult;
        }

        /// <summary>
        /// 异步接收
        /// </summary>
        /// <param name="length"></param>
        /// <returns></returns>
        protected virtual PLCResult<byte[]> BeginReceive(int length)
        {
            PLCResult<byte[]> plcResult = new PLCResult<byte[]>(new byte[length]);
            if (length == 0)
            {
                plcResult.Successed = false;
                plcResult.Message = "c:begin receive no length";
                return plcResult;
            }

            if (Socket == null)
            {
                plcResult.Successed = false;
                plcResult.Message = "c:begin receive no socket";
                return plcResult;
            }

            if (!Socket.Connected)
            {
                plcResult.Successed = false;
                plcResult.Message = "c:begin receive no connected";
                return plcResult;
            }

            SocketAsyncState sas = new SocketAsyncState();
            try
            {
                sas.Data = plcResult.Data;
                sas.Size = length;
                sas.Result = plcResult;
                Socket.BeginReceive(sas.Data, sas.Offset, sas.Size, SocketFlags.None, ReceiveCallback, sas);
            }
            catch (Exception ex)
            {
                plcResult.Successed = false;
                plcResult.Message = "c:begin receive " + ex.Message;
                plcResult.MessageDetail = ex.ToString();
                sas?.Close();
                sas = null;
                Socket?.Close();
                Socket = null;
            }

            sas?.WaitOne();
            sas?.Close();
            sas = null;

            return plcResult;
        }

        /// <summary>
        /// 接收结束
        /// </summary>
        /// <param name="iar"></param>
        private void ReceiveCallback(IAsyncResult iar)
        {
            if (iar.AsyncState is SocketAsyncState sas)
            {
                try
                {
                    int length = Socket.EndReceive(iar);
                    if (length > 0)
                    {
                        sas.Offset += length;
                        if (sas.Offset < sas.Size)
                        {
                            Socket.BeginReceive(sas.Data, sas.Offset, sas.Size - sas.Offset, SocketFlags.None, SendCallBack, iar);
                        }
                        else
                        {
                            sas.Set();
                        }
                    }
                    else
                    {
                        sas.Result.Successed = false;
                        sas.Result.Message = "c:receive callback other socket has closed";
                        Socket.Close();
                        Socket = null;
                        sas.Set();
                    }
                }
                catch (Exception ex)
                {
                    sas.Result.Successed = false;
                    sas.Result.Message = "c:receive callback " + ex.Message;
                    sas.Result.MessageDetail = ex.ToString();
                    Socket.Close();
                    Socket = null;
                    sas.Set();
                }
            }
        }
        #endregion
    }
}