How to return an async HttpWebResponse without blocking the main thread?

Question

I'm making a simple app for connecting to a webservice, and I'm having problems managing async requests.

The problem is with the function ProcessRequest, which basically makes an async HttpWebRequest, and returns the HttpWebResponse. As the request is async, I'm having problems with the return value, and with the functions calling the ProcessRequest method and waiting for the HttpWebResponse object.

By the way, the request in itself works perfectly, already tested inside functions so I don't need to return an HttpWebResponse.

I hope I'm making myself clear, as I said, this is my first time ever touching c#, .NET, and Windows Phone development. ( And WebRequests for that matter )

The errors that Visual Studio is throwing are:

1: Since 'System.AsyncCallback' returns void, a return keyword must not be followed by an object expression
2: Cannot convert lambda expression to delegate type 'System.AsyncCallback' because some of the return types in the block are not implicitly convertible to the delegate return type    

And this is the code:

namespace SimpleNoteConcept
{
public sealed class SimpleNote
{
    private static readonly SimpleNote _instance = new SimpleNote();
    private static string _authToken = string.Empty;
    private static string _email = string.Empty;
    private static string _authQsParams
    {
        get
        {
            if (string.IsNullOrEmpty(_authToken)) throw new SimpleNoteConceptAuthorisationException();
            return string.Format("auth={0}&email={1}", _authToken, _email);
        }
    }

    private SimpleNote() { }

    public static SimpleNote Instance
    {
        get { return _instance; }
    }

    public bool Connect(string email, string password)
    {
        try
        {
            StringParamCheck("email", email);
            StringParamCheck("password", password);

            var data = string.Format("email={0}&password={1}", email, password);
            var bytes = Encoding.GetEncoding("utf-8").GetBytes(data);
            data = Convert.ToBase64String(bytes);

            using (var resp = ProcessRequest( loginPath, "POST", content: data))
            {
                if (resp != null)
                {
                    _authToken = resp.Cookies["auth"].Value;
                    _email = email;
                    System.Diagnostics.Debug.WriteLine("Connection established! -> " + _authToken);
                    return true;
                }
                return false;
            }
        }
        catch (Exception)
        {
            throw;
        }

    }

    public void GetIndex(int length = 100, string mark = null, DateTimeOffset? since = null)
    {
        try
        {
            string sinceString = null;
            if (since.HasValue)
                sinceString = Json.DateTimeEpochConverter.DateToSeconds(since.Value);

            var queryParams = string.Format("{0}&length={1}&mark={2}&since={3}", _authQsParams, length, mark, sinceString);
            using (var resp = ProcessRequest( indexPath, "GET", queryParams))
            {
                var respContent = ReadResponseContent(resp);
                System.Diagnostics.Debug.WriteLine("GetIndex: " + respContent.ToString());
                //var notes = JsonConvert.DeserializeObject<Objects.NoteEnumerable<T>>(respContent);
                //return notes;
            }
        }
        catch (WebException ex)
        {
            var resp = (HttpWebResponse)ex.Response;
            switch (resp.StatusCode)
            {
                //401
                case HttpStatusCode.Unauthorized:
                    throw new SimpleNoteConceptAuthorisationException(ex);
                default:
                    throw;
            }
        }
        catch (Exception) { throw; }
    }

    /// <summary>
    /// Generic method to process a request to Simplenote.
    /// All publicly expose methods which interact with the store are processed though this.
    /// </summary>
    /// <param name="requestPath">The path to the request to be processed</param>
    /// <param name="method">The HTTP method for the request</param>
    /// <param name="content">The content to send in the request</param>
    /// <param name="queryParams">Queryparameters for the request</param>
    /// <returns>An HttpWebResponse continaing details returned from Simplenote</returns>
    private static HttpWebResponse ProcessRequest(string requestPath, string method,
                                                  string queryParams = null, string content = null)
    {
        try
        {
            var url = string.Format("{0}{1}{2}", "https://", domainPath, requestPath);
            if (!string.IsNullOrEmpty(queryParams)) url += "?" + queryParams;
            var request = WebRequest.Create(url) as HttpWebRequest;
            request.CookieContainer = new CookieContainer();
            request.Method = method;

            request.BeginGetRequestStream((e) =>
            {
                using (Stream stream = request.EndGetRequestStream(e))
                {
                    // Write data to the request stream
                    var bytesBody = Encoding.GetEncoding("utf-8").GetBytes(content);

                    stream.Write(bytesBody, 0, bytesBody.Length);
                    stream.Close();
                    stream.Dispose();
                }
                request.BeginGetResponse((callback) =>
                {
                    try
                    {
                        HttpWebResponse response = (HttpWebResponse)request.EndGetResponse(callback);
                        return response;

                    }
                    catch (WebException ex)
                    {
                        using (WebResponse Exresponse = ex.Response)
                        {
                            HttpWebResponse httpResponse = (HttpWebResponse)Exresponse;
                            System.Diagnostics.Debug.WriteLine("Error code: {0}", httpResponse.StatusCode);
                            using (Stream str = Exresponse.GetResponseStream())
                            {
                                string text = new StreamReader(str).ReadToEnd();
                                System.Diagnostics.Debug.WriteLine(text);
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        System.Diagnostics.Debug.WriteLine("Message: " + ex.Message);
                    }
                }, request);
            }, request);

        }
        catch (Exception)
        {
            throw;
        }
    }

    /// <summary>
    /// Reads the content from the response object
    /// </summary>
    /// <param name="resp">The response to be processed</param>
    /// <returns>A string of the response content</returns>
    private static string ReadResponseContent(HttpWebResponse resp)
    {
        if (resp == null) throw new ArgumentNullException("resp");
        using (var sr = new StreamReader(resp.GetResponseStream()))
        {
            return sr.ReadToEnd();
        }
    }

    /// <summary>
    /// String parameter helper method.
    /// Checks for null or empty, throws ArgumentNullException if true
    /// </summary>
    /// <param name="paramName">The name of the paramter being checked</param>
    /// <param name="value">The value to check</param>
    private void StringParamCheck(string paramName, string value)
    {
        if (string.IsNullOrEmpty(value)) throw new ArgumentNullException(paramName, "Value must not be null or string.Empty");
    }

} // Class End

} // Namespace End

Thanks in advance!

Answer 1

You cannot do async programming the same as normal. Here .Net is running the async parts in different thread, how can they be communicated? So what you can do is passing a delegate with your ProcessRequest method. which will take a parameter of HttpWebResponse.

Call your method like this:

Action<HttpWebResponse> actionDelegate = DoAfterGettingResponse;
ProcessRequest(indexPath, "GET", actionDelegate, queryParams);

Function that handle the response

public static void DoAfterGettingResponse(HttpWebResponse resp)
{
    if (resp != null)
    {
        _authToken = resp.Cookies["auth"].Value;
        _email = email;
        System.Diagnostics.Debug.WriteLine("Connection established! -> " + _authToken);

    }

    //Do anything else with the response
}    

ProcessRequest will have the new signature.

private static HttpWebResponse ProcessRequest(
    string requestPath, string method, Action<HttpWebResponse> reponseDelegate,
    string queryParams = null, string content = null)
{
    //Do what you are already doing        
}

And the place where you are returning response, just do

HttpWebResponse response = (HttpWebResponse)request.EndGetResponse(callback);
responseDelegate(response);

You can do this way or use events, fire an event passing HttpWebResponse as parameter and handle the response in the listener.