Techie Brains

How to write asynchronous Http Web Request in c#:
In this articel am going to explain you about how user http web request asynchronously
In order to implement this we need a HttpWebRequest class and IAsyncResult interface.

In the first step we need to create a user defined class for request state as bellow:


public class RequestState
    {
        const int BufferSize = 1024;
        public StringBuilder RequestData;
        public byte[] BufferRead;
        public WebRequest Request;
        public Stream ResponseStream;
        // Create Decoder for appropriate enconding type.
        public Decoder StreamDecode = Encoding.UTF8.GetDecoder();

        public RequestState()
        {
            BufferRead = new byte[BufferSize];
            RequestData = new StringBuilder(String.Empty);
            Request = null;
            ResponseStream = null;
        }
    }



In the next step we need to call a HttpwebRequest 


Calling HttpWebRequest
 // Get the URI from the command line.
            Uri httpSite = new Uri(url);

            // Create the request object.
            try
            {
                WebRequest wreq = WebRequest.Create(httpSite);
                wreq.Headers.Add("ip", HttpContext.Current.Request.Url.Host.ToLower());
                // Create the state object.
                RequestState rs = new RequestState();

                // Put the request into the state object so it can be passed around.
                rs.Request = wreq;

                // Issue the async request.
                IAsyncResult r = (IAsyncResult)wreq.BeginGetResponse(
                   new AsyncCallback(RespCallback), rs);

                //// Wait until the ManualResetEvent is set so that the application 
                //// does not exit until after the callback is called.
                //allDone.WaitOne();

                return rs.RequestData.ToString(); ;
            }
            catch(Exception exx)
            {
                return exx.Message;
            }


Then we need write a call back functions to get the asynchronous result I.e 
as mentioned below ReadCallback and RespCallback:

RespCallBack:

 private static void RespCallback(IAsyncResult ar)
        {
            // Get the RequestState object from the async result.
            RequestState rs = (RequestState)ar.AsyncState;

            // Get the WebRequest from RequestState.
            WebRequest req = rs.Request;

            // Call EndGetResponse, which produces the WebResponse object
            //  that came from the request issued above.
            WebResponse resp = req.EndGetResponse(ar);

            //  Start reading data from the response stream.
            Stream ResponseStream = resp.GetResponseStream();

            // Store the response stream in RequestState to read 
            // the stream asynchronously.
            rs.ResponseStream = ResponseStream;

            //  Pass rs.BufferRead to BeginRead. Read data into rs.BufferRead
            IAsyncResult iarRead = ResponseStream.BeginRead(rs.BufferRead, 0,
               BUFFER_SIZE, new AsyncCallback(ReadCallBack), rs);
        }



ReadCallBack:


  private static void ReadCallBack(IAsyncResult asyncResult)
        {
            // Get the RequestState object from AsyncResult.
            RequestState rs = (RequestState)asyncResult.AsyncState;

            // Retrieve the ResponseStream that was set in RespCallback. 
            Stream responseStream = rs.ResponseStream;

            // Read rs.BufferRead to verify that it contains data. 
            int read = responseStream.EndRead(asyncResult);
            if (read > 0)
            {
                // Prepare a Char array buffer for converting to Unicode.
                Char[] charBuffer = new Char[BUFFER_SIZE];

                // Convert byte stream to Char array and then to String.
                // len contains the number of characters converted to Unicode.
                int len =
                   rs.StreamDecode.GetChars(rs.BufferRead, 0, read, charBuffer, 0);

                String str = new String(charBuffer, 0, len);

                // Append the recently read data to the RequestData stringbuilder
                // object contained in RequestState.
                rs.RequestData.Append(
                   Encoding.ASCII.GetString(rs.BufferRead, 0, read));

                // Continue reading data until 
                // responseStream.EndRead returns –1.
                IAsyncResult ar = responseStream.BeginRead(
                   rs.BufferRead, 0, BUFFER_SIZE,
                   new AsyncCallback(ReadCallBack), rs);
            }
            else
            {
                if (rs.RequestData.Length > 0)
                {
                    //  Display data to the console.
                    string strContent;
                    strContent = rs.RequestData.ToString();
                }
                // Close down the response stream.
                responseStream.Close();
                // Set the ManualResetEvent so the main thread can exit.
                allDone.Set();
            }
            return;
        }    



I hope this will helps you in your  development