HttpWebRequest.EndGetResponse throws a NotSupportedException in Windows Phone 7

Question

in a Silverlight-Windows Phone 7-project I am creating an HttpWebRequest, get the RequestStream, write something into the Stream and try to get the response, but I always get a NotSupportedException: "System.Net.Browser.OHWRAsyncResult.AsyncWaitHandle threw an exception of type 'System.NotSupportedException'

My production code is far more complicated, but I can narrow it down to this small piece of code:

public class HttpUploadHelper
{
    private HttpWebRequest request;
    private RequestState state = new RequestState();

    public HttpUploadHelper(string url)
    {
        this.request = WebRequest.Create(url) as HttpWebRequest;
        state.Request = request;
    }

    public void Execute()
    {
        request.Method = "POST";
        this.request.BeginGetRequestStream(
            new AsyncCallback(BeginRequest), state);
    }

    private void BeginRequest(IAsyncResult ar)
    {
        Stream stream = state.Request.EndGetRequestStream(ar);
        state.Request.BeginGetResponse(
            new AsyncCallback(BeginResponse), state);
    }

    private void BeginResponse(IAsyncResult ar)
    {
        // BOOM: NotSupportedException was unhandled; 
        // {System.Net.Browser.OHWRAsyncResult}
        // AsyncWaitHandle = 'ar.AsyncWaitHandle' threw an 
        // exception of type 'System.NotSupportedException'
        HttpWebResponse response = state.Request.EndGetResponse(ar) as HttpWebResponse;
        Debug.WriteLine(response.StatusCode);
    }
}

public class RequestState
{
    public WebRequest Request;
}

}

Does anybody know what is wrong with this code?

Catholicon

Answer 1

The NotSupportedException can be thrown when the request stream isn't closed before the call to EndGetResponse. The WebRequest stream is still open and sending data to the server when you're attempting to get the response. Since stream implements the IDisposable interface, a simple solution is to wrap your code using the request stream in a using block:

private void BeginRequest(IAsyncResult ar)
{
    using (Stream stream = request.EndGetRequestStream(ar))
    {
        //write to stream in here.
    }
    state.Request.BeginGetResponse(
        new AsyncCallback(BeginResponse), state);
}

The using block will ensure that the stream is closed before you attempt to get the response from the web server.

Larhondalari

Answer 2

The issue is with how you're dealing with the accessing the original requests in the callback from BeginGetResponse.

Rather than holding a reference ot the state, get a reference back to the original request with:

var request = (HttpWebRequest)asynchronousResult.AsyncState;

Have a look at this very basic (but working) example of implementing logging in by posting email and password credentials to a website.

public static string Email;

public static string Password;


private void LoginClick(object sender, RoutedEventArgs e)
{
    Email = enteredEmailAddress.Text.Trim().ToLower();

    Password = enteredPassword.Password;

    var request = (HttpWebRequest)WebRequest.Create(App.Config.ServerUris.Login);

    request.ContentType = "application/x-www-form-urlencoded";
    request.Method = "POST";
    request.BeginGetRequestStream(ReadCallback, request);
}

private void ReadCallback(IAsyncResult asynchronousResult)
{
    var request = (HttpWebRequest)asynchronousResult.AsyncState;

    using (var postStream = request.EndGetRequestStream(asynchronousResult))
    {
        using (var memStream = new MemoryStream())
        {
            var content = string.Format("Password={0}&Email={1}",
                                        HttpUtility.UrlEncode(Password), 
                                        HttpUtility.UrlEncode(Email));

            var bytes = System.Text.Encoding.UTF8.GetBytes(content);

            memStream.Write(bytes, 0, bytes.Length);

            memStream.Position = 0;
            var tempBuffer = new byte[memStream.Length];
            memStream.Read(tempBuffer, 0, tempBuffer.Length);

            postStream.Write(tempBuffer, 0, tempBuffer.Length);
        }
    }

    request.BeginGetResponse(ResponseCallback, request);
}

private void ResponseCallback(IAsyncResult asynchronousResult)
{
    var request = (HttpWebRequest)asynchronousResult.AsyncState;

    using (var resp = (HttpWebResponse)request.EndGetResponse(asynchronousResult))
    {
        using (var streamResponse = resp.GetResponseStream())
        {
            using (var streamRead = new StreamReader(streamResponse))
            {
                string responseString = streamRead.ReadToEnd();

                // do something with responseString to check if login was successful
            }
        }
    }
}

Microbalance

Hi Matt, I am facing similar issue. Please help, #13599166 – Kilkenny

Answer 3

NotSupportedException can also be thrown when string url is too long. I had messed up and attached post data to url instead of post body. When the data was short, it worked just fine, but once it grew too large - EndGetResponse crashed.

Anomaly

Answer 4

Change this:

    state.Request.BeginGetResponse(
        new AsyncCallback(BeginResponse), state);

To this:

    state.Request.BeginGetResponse(BeginResponse, state);

Smaltite

Nah, "new AsyncCallback()" does nothing in this case, it can be omitted in general. – Wickner