public override void SendPacketAsync(string caption, byte[] data, Action <bool> callback, Action <TcpTransportResult> faultCallback = null)
        {
            var now = DateTime.Now;

            if (!FirstSendTime.HasValue)
            {
                FirstSendTime = now;
            }

            Helpers.Execute.BeginOnThreadPool(() =>
            {
                var isConnected  = false;
                var isConnecting = false;
                var result       = -1;

                lock (SyncRoot)
                {
                    isConnected = _isConnected;
                    if (!isConnected)
                    {
                        _requests.Add(new Tuple <byte[], Action <bool>, Action <TcpTransportResult> >(data, callback, faultCallback));
                        isConnecting = _requests.Count == 1;
                    }
                }

                if (isConnected)
                {
                    lock (SyncRoot)
                    {
                        try
                        {
                            result = _wrapper.SendPacket(data);
                        }
                        catch (Exception ex)
                        {
                        }
                    }

                    if (result > 0 && result < data.Length)
                    {
                        Helpers.Execute.ShowDebugMessage(string.Format("NativeTransport Send req={0} sent={1}", data.Length, result));
                        callback.SafeInvoke(true);
                    }
                    else if (result > 0)
                    {
                        callback.SafeInvoke(true);
                    }
                    else
                    {
                        faultCallback.SafeInvoke(new TcpTransportResult(new Exception("NativeTCPTransport error=" + result)));
                    }

                    return;
                }

                if (isConnecting)
                {
                    RaiseConnectingAsync();
                    result = -1;

                    try
                    {
                        //LOG("Connect start");
                        result = _wrapper.Connect();
                        //LOG("Connect end");
                    }
                    catch (Exception ex)
                    {
                    }

                    isConnected = result > 0;
                    if (!isConnected)
                    {
                        List <Tuple <byte[], Action <bool>, Action <TcpTransportResult> > > requests;
                        lock (SyncRoot)
                        {
                            _isConnected = false;
                            requests     = new List <Tuple <byte[], Action <bool>, Action <TcpTransportResult> > >(_requests);
                            _requests.Clear();
                        }

                        if (requests.Count > 0)
                        {
                            for (var i = 0; i < requests.Count; i++)
                            {
                                requests[i].Item3.SafeInvoke(new TcpTransportResult(new Exception("NativeTCPTransport connect error=" + result)));
                            }
                        }
                    }
                    else
                    {
                        Helpers.Execute.BeginOnThreadPool(() =>
                        {
                            try
                            {
                                _wrapper.StartReceive();
                            }
                            catch (Exception ex)
                            {
                            }
                        });

                        List <Tuple <byte[], Action <bool>, Action <TcpTransportResult> > > requests;
                        lock (SyncRoot)
                        {
                            _isConnected = true;
                            requests     = new List <Tuple <byte[], Action <bool>, Action <TcpTransportResult> > >(_requests);
                            _requests.Clear();
                        }

                        if (requests.Count > 0)
                        {
                            for (var i = 0; i < requests.Count; i++)
                            {
                                lock (SyncRoot)
                                {
                                    try
                                    {
                                        result = _wrapper.SendPacket(requests[i].Item1);
                                    }
                                    catch (Exception ex)
                                    {
                                    }
                                }
                                if (result > 0 && result < requests[i].Item1.Length)
                                {
                                    Helpers.Execute.ShowDebugMessage(string.Format("NativeTransport Send req={0} sent={1}", requests[i].Item1.Length, result));
                                    requests[i].Item2.SafeInvoke(true);
                                }
                                else if (result > 0)
                                {
                                    requests[i].Item2.SafeInvoke(true);
                                }
                                else
                                {
                                    requests[i].Item3.SafeInvoke(new TcpTransportResult(new Exception("NativeTCPTransport error=" + result)));
                                }
                            }
                        }
                    }
                }
            });
        }