/// <summary>
/// Simple method for making a request using WebHelper.
/// </summary>
/// <param name="url"></param>
/// <param name="options"></param>
/// <returns></returns>
public static WebHelperResponse MakeRequest(Uri url, WebHelperOptions options)
{
var web = new WebHelper(url);
web.Options = options;
return(web.MakeRequest());
}
/// <summary>
/// Simple method for making a request using WebHelper.
/// </summary>
/// <param name="url"></param>
/// <param name="options"></param>
/// <returns>The WaitHandle that can be used to determine when the request is complete.</returns>
public static WaitHandle MakeRequestAsync(Uri url, WebHelperOptions options)
{
var web = new WebHelper(url);
web.Options = options;
return(web.MakeRequestAsync());
}
/// <summary>
/// Creates an instance of WebHelperResponse.
/// </summary>
/// <param name="result"></param>
/// <param name="contentType"></param>
/// <param name="statusCode"></param>
/// <param name="contentEncoding"></param>
/// <param name="charSet"></param>
/// <param name="options"></param>
public WebHelperResponse(object result, string contentType, HttpStatusCode statusCode, string contentEncoding, string charSet, WebHelperOptions options)
{
Result = result;
ContentType = contentType;
StatusCode = statusCode;
ContentEncoding = contentEncoding;
CharacterSet = charSet;
Options = options;
}
/// <summary>
/// Simple and performant method to download files or any large amount of content.
/// </summary>
/// <param name="url"></param>
/// <param name="fileName"></param>
/// <param name="options"></param>
/// <returns>The WaitHandle that can be used to determine when the request is complete.</returns>
public static WaitHandle DownloadFileAsync(Uri url, string fileName, WebHelperOptions options = null)
{
var web = new WebHelper(url);
if (options != null)
{
web.Options = options;
}
web.ProcessResponseStream += (sender, e) => { ProcessFileResponse((WebHelper)sender, e, fileName); };
return(web.MakeRequestAsync());
}
/// <summary>
/// Simple method for making a request using WebHelper.
/// </summary>
/// <param name="url"></param>
/// <param name="fileName"></param>
/// <param name="options"></param>
/// <returns>The WaitHandle that can be used to determine when the request is complete.</returns>
public static WaitHandle DownloadFileAsync(string url, string fileName, WebHelperOptions options = null)
{
return(DownloadFileAsync(new Uri(url), fileName, options));
}
/// <summary>
/// Simple method for making a request using WebHelper.
/// </summary>
/// <param name="url"></param>
/// <param name="fileName"></param>
/// <param name="options"></param>
/// <returns></returns>
public static WebHelperResponse DownloadFile(string url, string fileName, WebHelperOptions options = null)
{
return(DownloadFile(new Uri(url), fileName, options));
}
/// <summary>
/// Simple method for making a request using WebHelper.
/// </summary>
/// <param name="url"></param>
/// <param name="options"></param>
/// <returns>The WaitHandle that can be used to determine when the request is complete.</returns>
public static WaitHandle MakeRequestAsync(string url, WebHelperOptions options)
{
return(MakeRequestAsync(new Uri(url), options));
}
/// <summary>
/// Simple method for making a request using WebHelper.
/// </summary>
/// <param name="url"></param>
/// <param name="options"></param>
/// <returns></returns>
public static WebHelperResponse MakeRequest(string url, WebHelperOptions options)
{
return(MakeRequest(new Uri(url), options));
}
/// <summary>
/// Creates an instance of WebHelper.
/// </summary>
/// <param name="url">The URL must be a valid http url.</param>
public WebHelper(Uri url)
{
Url = url;
Options = new WebHelperOptions();
}
private WebHelperResponse MakeRequest_Internal()
{
// Make sure we have valid options.
if (Options == null)
{
Options = new WebHelperOptions();
}
CancellationPending = false;
WebHelperResponse whResponse = null;
try
{
HttpWebRequest request = null;
bool sent = false;
var parameters = new WebParameters(Options.Values);
using (var contentType = ContentType ?? ContentType.CreateContentType(Options.Method, parameters))
{
request = CreateRequest(contentType);
sent = contentType.SendRequest(this, request);
}
RequestCompletedEventArgs completedArgs = null;
if (!sent)
{
if (!CancellationPending)
{
throw new InvalidOperationException("Unable to complete request. Unknown error.");
}
completedArgs = new RequestCompletedEventArgs(Options.State, true);
}
else
{
using (var response = (HttpWebResponse)request.GetResponse())
whResponse = ProcessResponse(response);
// even if a cancellation is pending, if we recieved the response, complete the request as normal.
if (whResponse != null)
{
completedArgs = new RequestCompletedEventArgs(whResponse, Options.State, false);
}
else if (CancellationPending)
{
completedArgs = new RequestCompletedEventArgs(whResponse, Options.State, true);
}
else
{
throw new InvalidOperationException("Unable to receive response. Unknown error.");
}
}
Post((arg) =>
{
OnRequestCompleted((RequestCompletedEventArgs)arg);
}, completedArgs);
}
catch (Exception ex)
{
var completedArgs = new RequestCompletedEventArgs(ex, Options.State, false);
Post((arg) =>
{
// Regardless of the outcome, RequestCompleted is guaranteed to be raised.
// Caller is responsible for checking the status of the request object to
// see if it is successful or not.
OnRequestCompleted((RequestCompletedEventArgs)arg);
}, completedArgs);
if (mAsyncOperation == null)
{
// Don't throw the exception if running on a thread. It can't be caught
// and makes it difficult to debug (cannot continue in Visual Studio).
throw;
}
}
finally
{
if (mAsyncOperation != null)
{
using (var done = new ManualResetEvent(false))
{
// Use the ManualResetEvent to ensure that the operation completes before
// we exit the method.
// This is used to ensure that the Wait method will not continue until
// after the final operation has been completed.
mAsyncOperation.PostOperationCompleted((arg) =>
{
mAsyncOperation = null;
done.Set();
}, null);
done.WaitOne();
}
}
}
return(whResponse);
}
