using AD.SocketForm.Model;

using NLog;

using System;

using System.Net.Sockets;

using System.Threading;

namespace AD.SocketForm.Service

{

    /// <summary>

    /// Socket连接类-可指定超时时间

    /// 参考网址：//www.cnblogs.com/weidagang2046/archive/2009/02/07/1385977.html

    /// </summary>

    public class SocketNewService

    {

        private Logger _logger = LogManager.GetCurrentClassLogger();

        /// <summary>

        /// 连接socket

        /// </summary>

        /// <param name="model"></param>

        /// <param name="timeout">单位：毫秒</param>

        /// <returns></returns>

        public Socket Create(HubModel model, int timeout)

        {

            var isConnected = false;

            var manualResetEvent = new ManualResetEvent(false);

            var tcpClient = new TcpClient();

            #region 异步方法委托

            Action<IAsyncResult> action = (asyncresult) =>

            {

                try

                {

                    TcpClient tcpclient = asyncresult.AsyncState as TcpClient;

                    if (tcpclient.Client != null)

                    {

                        tcpclient.EndConnect(asyncresult);

                        isConnected = true;

                    }

                    //Thread.Sleep(1000);

                }

                catch (Exception ex)

                {

                    _logger.Error(string.Format("获取socket异常,message:{0},stacktrace:{1}", ex.Message, ex.StackTrace));

                    isConnected = false;

                }

                finally

                {

                    manualResetEvent.Set();

                }

            };

            #endregion

            tcpClient.BeginConnect(model.IP, model.Port, new AsyncCallback(action), tcpClient);

            //判断在指定的时间以内是否收到释放锁的通知

            if (manualResetEvent.WaitOne(timeout, false))

            {

                //Console.WriteLine("连接成功");

                if (isConnected)

                {

                    return tcpClient.Client;

                }

                else

                {

                    return null;

                }

            }

            else

            {

                //Console.WriteLine("超时");

                tcpClient.Close();

                return null;

            }

        }

        /// <summary>

        /// 关闭socket

        /// </summary>

        /// <param name="socket"></param>

        public void Close(Socket socket)

        {

            if (socket != null)

            {

                socket.Close();

                socket = null;

            }

        }

        /// <summary>

        /// 判断Socket是否已连接

        /// </summary>

        /// <param name="socket"></param>

        /// <returns></returns>

        public bool IsConnected(Socket socket)

        {

            if (socket == null || socket.Connected == false)

            {

                return false;

            }

            bool blockingState = socket.Blocking;

            try

            {

                byte[] tmp = new byte[];

                socket.Blocking = false;

                socket.Send(tmp, , );

                return true;

            }

            catch (SocketException e)

            {

                // 产生 10035 == WSAEWOULDBLOCK 错误，说明被阻止了，但是还是连接的

                if (e.NativeErrorCode.Equals())

                {

                    return true;

                }

                else

                {

                    return false;

                }

            }

            catch (Exception ex)

            {

                _logger.Error(string.Format("检查Socket是否可连接时异常,message:{0},stacktrace:{1}", ex.Message, ex.StackTrace));

                return false;

            }

            finally

            {

                socket.Blocking = blockingState;    // 恢复状态

            }

        }

    }

}