[Release]Async Sockets (No packet-splitter)

        public WinSocket(string ExternalIp, ushort InternalPort, ushort ExternalPort)
        {
            try
            {
                OutIP = ExternalIp;
                OutPort = ExternalPort;
                _socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                _socket.Bind(new IPEndPoint(IPAddress.Any, InternalPort));
                _socket.Listen(500);
                _socket.BeginAccept(AcceptConnections, new Wrapper());
            }
            catch { }
        }


        private void AcceptConnections(IAsyncResult result)
        {
            try
            {
                Wrapper wr = result.AsyncState as Wrapper; //define instance of warpper
                wr._socket = _socket.EndAccept(result); //endaccept for warper socket with anysc result
                wr._Port = this.OutPort; 
                wr.buffer = new byte[65535]; //warrper buffer
                wr._socket.BeginReceive(wr.buffer, 0, 65535, SocketFlags.None, ReceiveData, wr); //begin receive on warpper socket (warrper buffer , offset , size , flag , async call back , warpper object)
                AnnounceNewConnection.Invoke(wr); //invoking "AnnounceNewConnection" event with warpper parameter 
                _socket.BeginAccept(AcceptConnections, new Wrapper()); //warpper socket begin accepting new connection
            }
            catch { }
        }
        private void ReceiveData(IAsyncResult result)
        {
            try
            {
                Wrapper wr = result.AsyncState as Wrapper;
                if (!wr._socket.Connected)
                    return;
                SocketError error = SocketError.Disconnecting;
                int size = wr._socket.EndReceive(result, out error);
                if (error == SocketError.Success && size != 0)
                {
                    byte[] buffer = new byte[size];
                    Buffer.BlockCopy(wr.buffer, 0, buffer, 0, size);
                    byte[] question = new byte[] { 1 };
                    AnnounceReceive.Invoke(buffer, wr, question);
                    if (wr._socket.Connected && question[0] == 1)
                        wr._socket.BeginReceive(wr.buffer, 0, 65535, SocketFlags.None, ReceiveData, wr);
                }
                else
                {
                    if (wr._socket.Connected)
                    {
                        wr._socket.Disconnect(true);
                    }
                    try
                    {
                        AnnounceDisconnection.Invoke(wr);
                    }
                    catch { }
                }
            }
            catch { }
        }

               private void AcceptConnections(IAsyncResult resultt)
        {
            try
            {
                ReceiveHeader(resultt);
            }
            catch { }
        }
        private byte[] receiveBuffer;
        private ushort type;
        private ushort size;
        public void ReceiveHeader(IAsyncResult result)
        {
            // only accept 4 bytes which is size and type
            Wrapper wr = result.AsyncState as Wrapper;
            wr._socket = _socket.EndAccept(result);
            wr._Port = this.OutPort;
            wr.buffer = new byte[4];
            wr._socket.BeginReceive(wr.buffer, 0, 4, SocketFlags.None, new AsyncCallback(ReceiveHeader_Callback), wr);
            AnnounceNewConnection.Invoke(wr);
            _socket.BeginAccept(AcceptConnections, new Wrapper());
        }
        public void ReceiveBody(IAsyncResult result)
        {
            Wrapper wr = result.AsyncState as Wrapper;
            wr._socket = _socket.EndAccept(result);
            wr._Port = this.OutPort;
            wr.buffer = new byte[size - 4];
            wr._socket.BeginReceive(wr.buffer, 0, (size - 4), SocketFlags.None, new AsyncCallback(ReceiveBody_Callback), wr);
            AnnounceNewConnection.Invoke(wr);
            _socket.BeginAccept(AcceptConnections, new Wrapper());
        }

        private void ReceiveHeader_Callback(IAsyncResult asyncResult)
        {
            try
            {
                Wrapper wr = asyncResult.AsyncState as Wrapper;
                if (!wr._socket.Connected)
                    return;
                SocketError error = SocketError.Disconnecting;
                int hSize = wr._socket.EndReceive(asyncResult, out error);
                if (error == SocketError.Success && size != 0)
                {
                    if (hSize == 4)
                    {
                        byte[] rBuffer = new byte[4];
                        System.Buffer.BlockCopy(receiveBuffer, 0, rBuffer, 0, 4);
                        DataPacket header = new DataPacket(rBuffer);
                        size = header.Size;
                        type = header.Type;
                        ReceiveBody(asyncResult);
                    }
                    else
                        AnnounceDisconnection.Invoke(wr);
                }
                else
                    AnnounceDisconnection.Invoke(wr);
            }
            catch
            {
            }
        }

        private void ReceiveBody_Callback(IAsyncResult asyncResult)
        {
            try
            {
                Wrapper wr = asyncResult.AsyncState as Wrapper;
                if (!wr._socket.Connected)
                    return;
                SocketError error = SocketError.Disconnecting;
                int bSize = wr._socket.EndReceive(asyncResult, out error);
                if (error == SocketError.Success)
                {
                    if (bSize == (size - 4))
                    {
                            byte[] rBuffer = new byte[size];
                            System.Buffer.BlockCopy(receiveBuffer, 0, rBuffer, 4, bSize);
                            DataPacket bpacket = new DataPacket(rBuffer);
                            bpacket.Size = size;
                            bpacket.Type = type;
                            byte[] question = new byte[] { 1 };
                            AnnounceReceive.Invoke(bpacket, wr, question);
                            if (wr._socket.Connected && question[0] == 1)
                                ReceiveHeader(asyncResult);

                        ReceiveHeader(asyncResult);
                    }
                    else
                        AnnounceDisconnection.Invoke(wr);
                }
                else
                    AnnounceDisconnection.Invoke(wr);
            }
            catch
            {}
        }
    }