private AsyncRequestResult BeginPostSerializableTTOut <T, TOut>(String controller, String action, String parameters, T value, RequestCompleted <TOut> callback, object asyncState, bool needResponseData)
where T : APIBaseRequest
{
byte[] bytedata;
var request = PreparePostRequest(controller, action, parameters, value, out bytedata);
var data = new AsyncGetObject <TOut>(request, callback, asyncState);
AsyncCallback asyncCallBack;
if (needResponseData)
{
asyncCallBack = EndGetPostSerializableT <TOut>;
}
else
{
asyncCallBack = EndGetPostSerializableNoData;
}
RequestData <TOut> rqd = new RequestData <TOut>
{
Data = bytedata,
AsyncData = data,
Callback = asyncCallBack
};
request.BeginGetRequestStream(EndGetRequestStream <TOut>, rqd);
return(new AsyncRequestResult(request));
}
private AsyncRequestResult BeginGetSerializableT <T>(String controller, String action, String parameters, RequestCompleted <T> callback, object asyncState)
{
var request = GetApiRequest(controller, action, parameters);
AsyncGetObject <T> data = new AsyncGetObject <T>(request, callback, asyncState);
request.BeginGetResponse(EndGetPostSerializableT <T>, data);
return(new AsyncRequestResult(request));
}
private static void EndGetPostSerializableT <T>(IAsyncResult res, bool hasResultData)
{
#if DEBUG
Thread.Sleep(1500);
#endif
AsyncGetObject <T> state = (AsyncGetObject <T>)res.AsyncState;
HttpWebResponse response;
try { response = (HttpWebResponse)state.Request.EndGetResponse(res); }
catch (ObjectDisposedException)
{
if (state.Callback != null)
{
state.Callback(default(T), RequestResult.Exit, HttpStatusCode.InternalServerError, null, state.AsyncState);
}
return;
}
catch (Exception ex)
{
if (state.Callback != null)
{
state.Callback(default(T), RequestResult.Error, HttpStatusCode.InternalServerError, ex, state.AsyncState);
return;
}
else
{
throw;
}
}
T result = default(T);
bool scs;
if (hasResultData)
{
XmlSerializer ser = SerializingHelper.GetSerializer(typeof(T));
scs = false;
try
{
using (var stream = response.GetResponseStream())
{
result = (T)ser.Deserialize(stream);
scs = true;
}
}
catch (Exception ex)
{
if (state.Callback != null)
{
state.Callback(default(T), RequestResult.Error, response.StatusCode, ex, state.AsyncState);
}
else
{
throw;
}
}
}
else
{
scs = true;
}
if (scs && state.Callback != null)
{
state.Callback(result, RequestResult.Success, response.StatusCode, null, state.AsyncState);
}
}
