Exemple #1
0
        /// <summary>

        /// Sends the request and handles any responses

        /// </summary>

        /// <param name="mb">The <see cref="MessageBuilder"/> used to contruct the request</param>

        /// <param name="del">The <see cref="ResponseReceivedEventHandler"/> for handling the response</param>

        /// <param name="waitForCallback"><c>true</c> to wait for a callback;<c>false</c> otherwise</param>

        /// <param name="state">An optional state object that will be passed into the response events associated with this request</param>

        protected void Send(MessageBuilder mb, ResponseReceivedEventHandler del, bool waitForCallback, object state)

        {
            // do some of this *before* we spin up a new thread so we can just throw an exception if the error occurs

            // *before* we even send the request (like when generating the message bytes)

            bool doSend = this.OnBeforeSend(mb);

            if (doSend)

            {
                byte[] bytes = mb.GetBytes();

                mb = null;



                // start a new thread for the network connection stuff

                ConnectionState cs = new ConnectionState(bytes, del, waitForCallback, state);

                ParameterizedThreadStart pts = new ParameterizedThreadStart(SendAsync);

                Thread t = new Thread(pts);

                t.Start(cs);
            }
        }
 /// <summary>
 /// Creates a new instance of the class.
 /// </summary>
 /// <param name="bytes">The request bytes to be written</param>
 /// <param name="del">The <see cref="ResponseReceivedEventHandler"/> method to call to handle the response</param>
 /// <param name="waitForCallback"><c>true</c> if the connection should wait for a callback;<c>false</c> otherwise</param>
 /// <param name="state">An optional state object that will be passed into the response events associated with this request</param>
 public ConnectionState(byte[] bytes, ResponseReceivedEventHandler del, bool waitForCallback, object state)
 {
     this.Bytes           = bytes;
     this.Delegate        = del;
     this.WaitForCallback = waitForCallback;
     this.UserState       = state;
 }
Exemple #3
0
        /// <summary>

        /// Sends the request on a background thread.

        /// </summary>

        /// <param name="obj">The obj.</param>

        /// <remarks>

        /// Using the built-in async methods (Begin*/End*) results in flakey behavior.

        /// Using the synchronous methods in another thread avoids the issue.

        /// </remarks>

        private void SendAsync(object obj)

        {
            TcpClient client = null;

            NetworkStream stream = null;



            try

            {
                ConnectionState cs = (ConnectionState)obj;

                byte[] bytes = cs.Bytes;

                ResponseReceivedEventHandler del = cs.Delegate;

                bool waitForCallback = cs.WaitForCallback;



                // connect

                try

                {
                    client = new TcpClient();

                    client.Connect(this.hostname, this.port);
                }

                catch

                {
                    OnCommunicationFailure(new Response(ErrorCode.NETWORK_FAILURE, ErrorDescription.CONNECTION_FAILURE), cs.UserState);
                }



                // write

                try

                {
                    stream = client.GetStream();

                    stream.Write(bytes, 0, bytes.Length);
                }

                catch

                {
                    OnCommunicationFailure(new Response(ErrorCode.NETWORK_FAILURE, ErrorDescription.WRITE_FAILURE), cs.UserState);
                }



                // read

                try

                {
                    string response = String.Empty;

                    byte[] buffer = new byte[4096];

                    while (!response.EndsWith(EOM, StringComparison.InvariantCulture))

                    {
                        int length = stream.Read(buffer, 0, buffer.Length);

                        if (length > 0)

                        {
                            response += System.Text.Encoding.UTF8.GetString(buffer, 0, length);
                        }

                        else

                        {
                            break;
                        }
                    }

                    del(response, cs.UserState);



                    // wait for callback

                    if (waitForCallback)

                    {
                        response = String.Empty;

                        buffer = new byte[4096];



                        while (!response.EndsWith(EOM, StringComparison.InvariantCulture))

                        {
                            int length = stream.Read(buffer, 0, buffer.Length);

                            if (length > 0)

                            {
                                response += System.Text.Encoding.UTF8.GetString(buffer, 0, length);
                            }

                            else

                            {
                                break;
                            }
                        }

                        del(response, cs.UserState);
                    }
                }

                catch

                {
                    OnCommunicationFailure(new Response(ErrorCode.NETWORK_FAILURE, ErrorDescription.READ_FAILURE), cs.UserState);
                }
            }

            catch (Exception ex)

            {
                Growl.CoreLibrary.DebugInfo.WriteLine(ex.ToString());
            }

            finally

            {
                try

                {
                    if (client != null && client.Client != null)

                    {
                        client.Client.Blocking = true;

                        try { client.Client.Shutdown(SocketShutdown.Both); }

                        catch { }

                        client.Client.Close();

                        client.Close();
                    }



                    if (stream != null)

                    {
                        stream.Close();

                        stream.Dispose();

                        stream = null;
                    }



                    client = null;
                }

                catch

                {
                    // suppress
                }
            }
        }
 /// <summary>
 /// Creates a new instance of the class.
 /// </summary>
 /// <param name="bytes">The request bytes to be written</param>
 /// <param name="del">The <see cref="ResponseReceivedEventHandler"/> method to call to handle the response</param>
 /// <param name="waitForCallback"><c>true</c> if the connection should wait for a callback;<c>false</c> otherwise</param>
 /// <param name="state">An optional state object that will be passed into the response events associated with this request</param>
 public ConnectionState(byte[] bytes, ResponseReceivedEventHandler del, bool waitForCallback, object state)
 {
     this.Bytes = bytes;
     this.Delegate = del;
     this.WaitForCallback = waitForCallback;
     this.UserState = state;
 }
        /// <summary>
        /// Sends the request and handles any responses
        /// </summary>
        /// <param name="mb">The <see cref="MessageBuilder"/> used to contruct the request</param>
        /// <param name="del">The <see cref="ResponseReceivedEventHandler"/> for handling the response</param>
        /// <param name="waitForCallback"><c>true</c> to wait for a callback;<c>false</c> otherwise</param>
        /// <param name="state">An optional state object that will be passed into the response events associated with this request</param>
        protected void Send(MessageBuilder mb, ResponseReceivedEventHandler del, bool waitForCallback, object state)
        {
            // do some of this *before* we spin up a new thread so we can just throw an exception if the error occurs
            // *before* we even send the request (like when generating the message bytes)
            bool doSend = this.OnBeforeSend(mb);
            if (doSend)
            {
                byte[] bytes = mb.GetBytes();
                mb = null;

                // start a new thread for the network connection stuff
                ConnectionState cs = new ConnectionState(bytes, del, waitForCallback, state);
                ParameterizedThreadStart pts = new ParameterizedThreadStart(SendAsync);
                Thread t = new Thread(pts);
                t.Start(cs);
            }
        }