/// <summary> /// Loads this <see cref="MyCustomRssFeed"/> instance asynchronously using the specified <see cref="Uri"/>, <see cref="SyndicationResourceLoadSettings"/>, <see cref="ICredentials"/>, and <see cref="IWebProxy"/>. /// </summary> /// <param name="source">A <see cref="Uri"/> that represents the URL of the syndication resource XML data.</param> /// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> object used to configure the <see cref="MyCustomRssFeed"/> instance. This value can be <b>null</b>.</param> /// <param name="options">A <see cref="WebRequestOptions"/> that holds options that should be applied to web requests.</param> /// <param name="userToken">A user-defined object that is passed to the method invoked when the asynchronous operation completes.</param> /// <remarks> /// <para> /// To receive notification when the operation has completed or the operation has been canceled, add an event handler to the <see cref="Loaded"/> event. /// You can cancel a <see cref="LoadAsync(Uri, SyndicationResourceLoadSettings, ICredentials, IWebProxy, Object)"/> operation by calling the <see cref="LoadAsyncCancel()"/> method. /// </para> /// <para> /// After calling <see cref="LoadAsync(Uri, SyndicationResourceLoadSettings, ICredentials, IWebProxy, Object)"/>, /// you must wait for the load operation to complete before attempting to load the syndication resource using the <see cref="LoadAsync(Uri, Object)"/> method. /// </para> /// </remarks> /// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="FormatException">The <paramref name="source"/> data does not conform to the expected syndication content format. In this case, the feed remains empty.</exception> /// <exception cref="InvalidOperationException">This <see cref="MyCustomRssFeed"/> has a <see cref="LoadAsync(Uri, SyndicationResourceLoadSettings, ICredentials, IWebProxy, Object)"/> call in progress.</exception> public void LoadAsync(Uri source, SyndicationResourceLoadSettings settings, WebRequestOptions options, Object userToken) { Guard.ArgumentNotNull(source, "source"); if (settings == null) { settings = new SyndicationResourceLoadSettings(); } if (this.LoadOperationInProgress) { throw new InvalidOperationException(); } this.LoadOperationInProgress = true; this.AsyncLoadHasBeenCancelled = false; asyncHttpWebRequest = SyndicationEncodingUtility.CreateWebRequest(source, options); asyncHttpWebRequest.Timeout = Convert.ToInt32(settings.Timeout.TotalMilliseconds, System.Globalization.NumberFormatInfo.InvariantInfo); object[] state = new object[6] { asyncHttpWebRequest, this, source, settings, options, userToken }; IAsyncResult result = asyncHttpWebRequest.BeginGetResponse(new AsyncCallback(AsyncLoadCallback), state); ThreadPool.RegisterWaitForSingleObject(result.AsyncWaitHandle, new WaitOrTimerCallback(AsyncTimeoutCallback), state, settings.Timeout, true); }
/// <summary> /// Called when a corresponding asynchronous send operation completes. /// </summary> /// <param name="result">The result of the asynchronous operation.</param> private static void AsyncSendCallback(IAsyncResult result) { XmlRpcResponse response = null; WebRequest httpWebRequest = null; XmlRpcClient client = null; Uri host = null; XmlRpcMessage message = null; WebRequestOptions options = null; object userToken = null; if (result.IsCompleted) { object[] parameters = (object[])result.AsyncState; httpWebRequest = parameters[0] as WebRequest; client = parameters[1] as XmlRpcClient; host = parameters[2] as Uri; message = parameters[3] as XmlRpcMessage; options = parameters[4] as WebRequestOptions; userToken = parameters[5]; if (client != null) { WebResponse httpWebResponse = (WebResponse)httpWebRequest.EndGetResponse(result); response = new XmlRpcResponse(httpWebResponse); client.OnMessageSent(new XmlRpcMessageSentEventArgs(host, message, response, options, userToken)); client.SendOperationInProgress = false; } } }
private static HttpRequestMessage CreateRequestInternal(LazyUri url, WebRequestOptions options, bool forceSameUrl, int redirectionIndex #if WEBCLIENT , out HttpContent requestContent #endif ) { if (!forceSameUrl) { url = MaybeAddAdditionalQueryParameters(url, options); } var pathAndQueryConsistentUrl = url.GetPathAndQueryConsistentUrlIfCached(); if (pathAndQueryConsistentUrl == null) { if ( #if NET35 url.FragmentParameters.Count() #else url.FragmentParameters.Count #endif >= Configuration_MinNumberOfFragmentParametersForAdHocRequestUri) { pathAndQueryConsistentUrl = url.GetPathAndQueryAsUri(); } else { pathAndQueryConsistentUrl = url.PathAndQueryConsistentUrl; } }
public async Task <HttpResponseMessage> GetResponseAsync(long startPosition) { if (partialDownload != null && startPosition == 0) { var c = partialDownload; partialDownload = null; return(c); } var options = new WebRequestOptions() { Timeout = 30000, TimeoutSecondRetrialAfterError = 10000, TimeoutStartSecondRetrial = null }; var url = new LazyUri(this.Url); HttpExtensionMethods.ProcessMetaParameters(url, options); if (startPosition != 0) { options.AddHeader("Range", "bytes=" + startPosition + "-"); } var response = await HttpExtensionMethods.GetResponseAsync(url, options); SaveResponseInfo(response, null); return(response); //return (await HttpExtensionMethods.SendAsync(url, options, null)).Response; }
internal HtmlNode RecreateNode(LazyUri url, WebRequestOptions cookieDestination, string cachePath) { if (this.ExceptionType != null) { throw Caching.RebuildException(this, url); } if (this.RedirectUrl != null && this.Result == null) { return(null); } HtmlNode html; if (this.DataType == WebCacheDataType.Json) { html = FizzlerCustomSelectors.JsonToHtml(this.Result, 0, null); } else if (this.DataType == WebCacheDataType.Text) { var d = new HtmlDocument(); html = d.DocumentNode; html.SetAttributeValue("plain-text", "1"); html.AppendTextNode(this.Result); } else { html = this.Result.AsHtmlDocumentNode(); } var docnode = html.OwnerDocument.DocumentNode; docnode.SetAttributeValue("from-cache", "1"); if (this.Headers != null) { foreach (var header in this.Headers) { docnode.SetAttributeValue("header-" + header.Key, header.Value); } } if (this.Cookies != null) { foreach (var cookie in this.Cookies) { cookieDestination.AddCookie(cookie.Key, cookie.Value, PriorityCookie.PRIORITY_FromCache); } } #if DESKTOP if (this.DateRetrieved == default(DateTime)) { this.DateRetrieved = File.GetLastWriteTimeUtc(cachePath); } #endif docnode.SetAttributeValue("date-retrieved", this.DateRetrieved.ToString("o")); if (RedirectUrl != null) { docnode.SetAttributeValue("redirect-url", this.RedirectUrl.AbsoluteUri); } docnode.SetAttributeValue("requested-url", url.AbsoluteUri); html.OwnerDocument.SetPageUrl(this.PageUrl ?? this.Url); return(html); }
/// <summary> /// Called when a corresponding asynchronous load operation completes. /// </summary> /// <param name="result">The result of the asynchronous operation.</param> private static void AsyncLoadCallback(IAsyncResult result) { System.Text.Encoding encoding = System.Text.Encoding.UTF8; XPathNavigator navigator = null; WebRequest httpWebRequest = null; MyCustomRssFeed feed = null; Uri source = null; WebRequestOptions options = null; SyndicationResourceLoadSettings settings = null; if (result.IsCompleted) { object[] parameters = (object[])result.AsyncState; httpWebRequest = parameters[0] as WebRequest; feed = parameters[1] as MyCustomRssFeed; source = parameters[2] as Uri; settings = parameters[3] as SyndicationResourceLoadSettings; options = parameters[4] as WebRequestOptions; object userToken = parameters[5]; if (feed != null) { WebResponse httpWebResponse = (WebResponse)httpWebRequest.EndGetResponse(result); using (Stream stream = httpWebResponse.GetResponseStream()) { if (settings != null) { encoding = settings.CharacterEncoding; } using (StreamReader streamReader = new StreamReader(stream, encoding)) { XmlReaderSettings readerSettings = new XmlReaderSettings(); readerSettings.IgnoreComments = true; readerSettings.IgnoreWhitespace = true; readerSettings.DtdProcessing = DtdProcessing.Ignore; using (XmlReader reader = XmlReader.Create(streamReader, readerSettings)) { if (encoding == System.Text.Encoding.UTF8) { navigator = SyndicationEncodingUtility.CreateSafeNavigator(source, options, null); } else { navigator = SyndicationEncodingUtility.CreateSafeNavigator(source, options, settings.CharacterEncoding); } // Code to load the syndication resource using the XPathNavigator would go here. // If you support legacy formats, you would use a SyndicationResourceAdapter to fill the feed; // otherwise you would utilize the feed's Load method. feed.OnFeedLoaded(new SyndicationResourceLoadedEventArgs(navigator, source, options, userToken)); } } } feed.LoadOperationInProgress = false; } } }
//============================================================ // CALLBACK DELEGATE METHODS //============================================================ #region AsyncSendCallback(IAsyncResult result) /// <summary> /// Called when a corresponding asynchronous send operation completes. /// </summary> /// <param name="result">The result of the asynchronous operation.</param> private static void AsyncSendCallback(IAsyncResult result) { //------------------------------------------------------------ // Local members //------------------------------------------------------------ TrackbackResponse response = null; WebRequest httpWebRequest = null; TrackbackClient client = null; Uri host = null; TrackbackMessage message = null; WebRequestOptions options = null; object userToken = null; //------------------------------------------------------------ // Determine if the async send operation completed //------------------------------------------------------------ if (result.IsCompleted) { //------------------------------------------------------------ // Extract the send operations parameters from the user state //------------------------------------------------------------ object[] parameters = (object[])result.AsyncState; httpWebRequest = parameters[0] as WebRequest; client = parameters[1] as TrackbackClient; host = parameters[2] as Uri; message = parameters[3] as TrackbackMessage; options = parameters[4] as WebRequestOptions; userToken = parameters[5]; //------------------------------------------------------------ // Verify expected parameters were found //------------------------------------------------------------ if (client != null) { //------------------------------------------------------------ // Get the Trackback response to the Trackback ping request //------------------------------------------------------------ WebResponse httpWebResponse = (WebResponse)httpWebRequest.EndGetResponse(result); //------------------------------------------------------------ // Extract the Trackback response to the Trackback ping request //------------------------------------------------------------ response = new TrackbackResponse(httpWebResponse); //------------------------------------------------------------ // Raise SendCompleted event to notify registered handlers of state change //------------------------------------------------------------ client.OnMessageSent(new TrackbackMessageSentEventArgs(host, message, response, options, userToken)); //------------------------------------------------------------ // Reset async operation in progress indicator //------------------------------------------------------------ client.SendOperationInProgress = false; } } }
/// <summary> /// Initializes a new instance of the <see cref="XmlRpcMessageSentEventArgs"/> class using the supplied parameters. /// </summary> /// <param name="host">A <see cref="Uri"/> that represents the URL of the host computer used for the XML-RPC transaction.</param> /// <param name="message">An <see cref="XmlRpcMessage"/> that represents the remote procedure call payload.</param> /// <param name="response">An <see cref="XmlRpcResponse"/> that represents the response to the remote procedure call.</param> /// <param name="credentials">A <see cref="ICredentials"/> that represents the authentication credentials utilized by the client when making the remote procedure call. This parameter may be <b>null</b>.</param> /// <param name="proxy">A <see cref="IWebProxy"/> that represents the web proxy utilized by the client to proxy the remote procedure call. This parameter may be <b>null</b>.</param> /// <param name="state">A <see cref="Object"/> containing state information that was passed to the asynchronous send operation. This parameter may be <b>null</b>.</param> /// <exception cref="ArgumentNullException">The <paramref name="host"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="message"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="response"/> is a null reference (Nothing in Visual Basic).</exception> public XmlRpcMessageSentEventArgs(Uri host, XmlRpcMessage message, XmlRpcResponse response, ICredentials credentials, IWebProxy proxy, Object state) { Guard.ArgumentNotNull(host, "host"); Guard.ArgumentNotNull(message, "message"); Guard.ArgumentNotNull(response, "response"); eventHost = host; eventMessage = message; eventResponse = response; eventOptions = new WebRequestOptions(credentials, proxy); eventUserToken = state; }
/// <summary> /// Initializes a new instance of the <see cref="XmlRpcMessageSentEventArgs"/> class using the supplied parameters. /// </summary> /// <param name="host">A <see cref="Uri"/> that represents the URL of the host computer used for the XML-RPC transaction.</param> /// <param name="message">An <see cref="XmlRpcMessage"/> that represents the remote procedure call payload.</param> /// <param name="response">An <see cref="XmlRpcResponse"/> that represents the response to the remote procedure call.</param> /// <param name="options">A <see cref="WebRequestOptions"/> that holds options that should be applied to web requests.</param> /// <param name="state">A <see cref="Object"/> containing state information that was passed to the asynchronous send operation. This parameter may be <b>null</b>.</param> /// <exception cref="ArgumentNullException">The <paramref name="host"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="message"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="response"/> is a null reference (Nothing in Visual Basic).</exception> public XmlRpcMessageSentEventArgs(Uri host, XmlRpcMessage message, XmlRpcResponse response, WebRequestOptions options, Object state) { Guard.ArgumentNotNull(host, "host"); Guard.ArgumentNotNull(message, "message"); Guard.ArgumentNotNull(response, "response"); eventHost = host; eventMessage = message; eventResponse = response; eventOptions = options ?? new WebRequestOptions(); eventUserToken = state; }
private static WebRequestOptions ProcessWebRequestOptions(dynamic options) { var webRequestOptions = new WebRequestOptions() { Retries = DefaultServiceRetries, Timeout = DefaultTimeout * 1000 }; // Decode options if (options != null) { var o = (object)options; IDictionary <string, object> convertedValue = o.FromScriptValue() as IDictionary <string, object>; if (convertedValue.ContainsKey("Retries")) { webRequestOptions.Retries = (int)convertedValue["Retries"]; } if (convertedValue.ContainsKey("Timeout")) { webRequestOptions.Timeout = (int)convertedValue["Timeout"] * 1000; } if (convertedValue.ContainsKey("Headers")) { webRequestOptions.Headers = convertedValue["Headers"] as Dictionary <string, object>; } if (convertedValue.ContainsKey("KeepResponseAsString")) { webRequestOptions.KeepResponseAsString = Convert.ToBoolean(convertedValue["KeepResponseAsString"]); } if (convertedValue.ContainsKey("KeepRequestAsString")) { webRequestOptions.KeepRequestAsString = Convert.ToBoolean(convertedValue["KeepRequestAsString"]); } } if (webRequestOptions.Timeout > MaxTimeout) { logger.WarnFormat("Script requesting timeout of {0} which is greater than max allowed value of {1}", webRequestOptions.Timeout, MaxTimeout); webRequestOptions.Timeout = MaxTimeout; } return(webRequestOptions); }
internal static HtmlNode TryReadFromCache(string cachePath, LazyUri url, WebRequestOptions cookieDestination) { var data = Caching.TryReadCacheFile(cachePath); if (data == null) { return(null); } if (data.ExceptionType == null || !Caching.IgnoreCachedFailedRequests) { Utils.RaiseWebRequestEvent(url, true); return(data.RecreateNode(url, cookieDestination, cachePath)); } return(null); }
/// <summary> /// Loads the syndication resource from the supplied <see cref="Uri"/> using the specified <see cref="ICredentials">credentials</see>, <see cref="IWebProxy">proxy</see> and <see cref="SyndicationResourceLoadSettings"/>. /// </summary> /// <param name="source">A <see cref="Uri"/> that points to the location of the web resource used to load the syndication resource.</param> /// <param name="options">A <see cref="WebRequestOptions"/> that holds options that should be applied to web requests.</param> /// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> object used to configure the <see cref="AtomEntry"/> instance. This value can be <b>null</b>.</param> /// <remarks> /// <para> /// <list type="bullet"> /// <item> /// <description> /// If <paramref name="settings"/> has a <see cref="SyndicationResourceLoadSettings.CharacterEncoding">character encoding</see> of <see cref="System.Text.Encoding.UTF8"/> /// the character encoding of the <paramref name="source"/> will be attempt to be determined automatically, otherwise the specified character encoding will be used. /// If automatic detection fails, a character encoding of <see cref="System.Text.Encoding.UTF8"/> is used by default. /// </description> /// </item> /// <item> /// <description> /// After the load operation has successfully completed, the <see cref="AtomEntry.Loaded"/> event will be raised. /// </description> /// </item> /// </list> /// </para> /// </remarks> /// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="FormatException">The <paramref name="source"/> data does not conform to the expected syndication content format. In this case, the entry remains empty.</exception> /// <exception cref="XmlException">There is a load or parse error in the XML. In this case, the entry remains empty.</exception> public new void Load(Uri source, WebRequestOptions options, SyndicationResourceLoadSettings settings) { base.Load(source, options, settings); AtomPublishingEditedSyndicationExtension editedExtension = this.FindExtension(AtomPublishingEditedSyndicationExtension.MatchByType) as AtomPublishingEditedSyndicationExtension; if (editedExtension != null) { this.EditedOn = editedExtension.Context.EditedOn; } AtomPublishingControlSyndicationExtension controlExtension = this.FindExtension(AtomPublishingControlSyndicationExtension.MatchByType) as AtomPublishingControlSyndicationExtension; if (controlExtension != null) { this.IsDraft = controlExtension.Context.IsDraft; } }
/// <summary> /// Initializes a new instance of the <see cref="TrackbackMessageSentEventArgs"/> class using the supplied parameters. /// </summary> /// <param name="host">A <see cref="Uri"/> that represents the URL of the host computer used for the XML-RPC transaction.</param> /// <param name="message">An <see cref="TrackbackMessage"/> that represents the Trackback ping request payload.</param> /// <param name="response">An <see cref="TrackbackResponse"/> that represents the response to the Trackback ping request.</param> /// <param name="options">A <see cref="WebRequestOptions"/> that holds options that should be applied to web requests.</param> /// <param name="state">A <see cref="Object"/> containing state information that was passed to the asynchronous send operation. This parameter may be <b>null</b>.</param> /// <exception cref="ArgumentNullException">The <paramref name="host"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="message"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="response"/> is a null reference (Nothing in Visual Basic).</exception> public TrackbackMessageSentEventArgs(Uri host, TrackbackMessage message, TrackbackResponse response, WebRequestOptions options, Object state) { //------------------------------------------------------------ // Validate parameters //------------------------------------------------------------ Guard.ArgumentNotNull(host, "host"); Guard.ArgumentNotNull(message, "message"); Guard.ArgumentNotNull(response, "response"); //------------------------------------------------------------ // Initialize class members //------------------------------------------------------------ eventHost = host; eventMessage = message; eventResponse = response; eventOptions = options ?? new WebRequestOptions(); eventUserToken = state; }
private static LazyUri MaybeAddAdditionalQueryParameters(LazyUri url, WebRequestOptions options) { bool cloned = false; if (options != null && options.AdditionalQueryParameters != null) { foreach (var item in Flatten(options.AdditionalQueryParameters)) { if (!cloned) { cloned = true; url = url.Clone(); } url.AppendQueryParameter(item.Key, ToString(item.Value)); } } return(url); }
/// <summary> /// Initializes a new instance of the <see cref="XmlRpcMessageSentEventArgs"/> class using the supplied parameters. /// </summary> /// <param name="host">A <see cref="Uri"/> that represents the URL of the host computer used for the XML-RPC transaction.</param> /// <param name="message">An <see cref="XmlRpcMessage"/> that represents the remote procedure call payload.</param> /// <param name="response">An <see cref="XmlRpcResponse"/> that represents the response to the remote procedure call.</param> /// <param name="credentials">A <see cref="ICredentials"/> that represents the authentication credentials utilized by the client when making the remote procedure call. This parameter may be <b>null</b>.</param> /// <param name="proxy">A <see cref="IWebProxy"/> that represents the web proxy utilized by the client to proxy the remote procedure call. This parameter may be <b>null</b>.</param> /// <param name="state">A <see cref="Object"/> containing state information that was passed to the asynchronous send operation. This parameter may be <b>null</b>.</param> /// <exception cref="ArgumentNullException">The <paramref name="host"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="message"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="response"/> is a null reference (Nothing in Visual Basic).</exception> public XmlRpcMessageSentEventArgs(Uri host, XmlRpcMessage message, XmlRpcResponse response, ICredentials credentials, IWebProxy proxy, Object state) { //------------------------------------------------------------ // Validate parameters //------------------------------------------------------------ Guard.ArgumentNotNull(host, "host"); Guard.ArgumentNotNull(message, "message"); Guard.ArgumentNotNull(response, "response"); //------------------------------------------------------------ // Initialize class members //------------------------------------------------------------ eventHost = host; eventMessage = message; eventResponse = response; eventOptions = new WebRequestOptions(credentials, proxy); eventUserToken = state; }
internal HtmlNode RecreateNode(LazyUri url, WebRequestOptions cookieDestination, string cachePath) { if (this.ExceptionType != null) throw Caching.RebuildException(this, url); if (this.RedirectUrl != null && this.Result == null) return null; HtmlNode html; if (this.DataType == WebCacheDataType.Json) html = FizzlerCustomSelectors.JsonToHtml(this.Result, 0, null); else if (this.DataType == WebCacheDataType.Text) { var d = new HtmlDocument(); html = d.DocumentNode; html.SetAttributeValue("plain-text", "1"); html.AppendTextNode(this.Result); } else { html = this.Result.AsHtmlDocumentNode(); } var docnode = html.OwnerDocument.DocumentNode; docnode.SetAttributeValue("from-cache", "1"); if (this.Headers != null) { foreach (var header in this.Headers) { docnode.SetAttributeValue("header-" + header.Key, header.Value); } } if (this.Cookies != null) { foreach (var cookie in this.Cookies) { cookieDestination.AddCookie(cookie.Key, cookie.Value, PriorityCookie.PRIORITY_FromCache); } } #if DESKTOP if (this.DateRetrieved == default(DateTime)) this.DateRetrieved = File.GetLastWriteTimeUtc(cachePath); #endif docnode.SetAttributeValue("date-retrieved", this.DateRetrieved.ToString("o")); if (RedirectUrl != null) docnode.SetAttributeValue("redirect-url", this.RedirectUrl.AbsoluteUri); docnode.SetAttributeValue("requested-url", url.AbsoluteUri); html.OwnerDocument.SetPageUrl(this.PageUrl ?? this.Url); return html; }
/// <summary> /// Loads the syndication resource from the supplied <see cref="Uri"/> using the specified <see cref="ICredentials">credentials</see>, <see cref="IWebProxy">proxy</see> and <see cref="SyndicationResourceLoadSettings"/>. /// </summary> /// <param name="source">A <see cref="Uri"/> that points to the location of the web resource used to load the syndication resource.</param> /// <param name="options">A <see cref="WebRequestOptions"/> that holds options that should be applied to web requests.</param> /// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> object used to configure the <see cref="MyCustomRssFeed"/> instance. This value can be <b>null</b>.</param> /// <remarks> /// <para> /// <list type="bullet"> /// <item> /// <description> /// If <paramref name="settings"/> has a <see cref="SyndicationResourceLoadSettings.CharacterEncoding">character encoding</see> of <see cref="System.Text.Encoding.UTF8"/> /// the character encoding of the <paramref name="source"/> will be attempt to be determined automatically, otherwise the specified character encoding will be used. /// If automatic detection fails, a character encoding of <see cref="System.Text.Encoding.UTF8"/> is used by default. /// </description> /// </item> /// <item> /// <description> /// After the load operation has successfully completed, the <see cref="MyCustomRssFeed.Loaded"/> event will be raised. /// </description> /// </item> /// </list> /// </para> /// </remarks> /// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="FormatException">The <paramref name="source"/> data does not conform to the expected syndication content format. In this case, the feed remains empty.</exception> /// <exception cref="XmlException">There is a load or parse error in the XML. In this case, the feed remains empty.</exception> public void Load(Uri source, WebRequestOptions options, SyndicationResourceLoadSettings settings) { XPathNavigator navigator = null; Guard.ArgumentNotNull(source, "source"); if (settings == null) { settings = new SyndicationResourceLoadSettings(); } if (settings.CharacterEncoding == System.Text.Encoding.UTF8) { navigator = SyndicationEncodingUtility.CreateSafeNavigator(source, options, null); } else { navigator = SyndicationEncodingUtility.CreateSafeNavigator(source, options, settings.CharacterEncoding); } this.Load(navigator, settings, new SyndicationResourceLoadedEventArgs(navigator, source, options)); }
internal static async Task <HttpResponseMessage> GetAzureResponseAsync(string container, string name, long startPosition, Shaman.Types.WebFile file) { var options = new WebRequestOptions() { Timeout = 30000, TimeoutSecondRetrialAfterError = 10000, TimeoutStartSecondRetrial = null }; if (startPosition != 0) { options.AddHeader("Range", "bytes=" + startPosition + "-"); } var response = (await ExtensionMethods.SendAsync(new LazyUri(AzureApi.GetUrlForBlob(container, name)), options, null)).Response; IEnumerable <string> errs; if (response.Headers.TryGetValues("x-ms-meta-err", out errs)) { throw MediaStream.ExceptionFromCachedResponse(errs.First()); } return(response); }
public Task PopulateRequestsAsync() { return this.Requests.Where(x => x.RequestBody == null).ForEachThrottledAsync(async x => { try { var req = new WebRequestOptions(); foreach (var header in x.RequestHeaders) { req.AddHeader(header.Key, header.Value); } using (var resp = await new LazyUri(x.Url).GetResponseAsync(req)) { using (var sr = new StreamReader(await resp.Content.ReadAsStreamAsync())) { x.ResponseBody = await sr.ReadToEndAsync(); } } } catch (Exception) { } }, 1); }
/// <summary> /// Loads the syndication resource from the supplied <see cref="Uri"/> using the specified <see cref="ICredentials">credentials</see>, <see cref="IWebProxy">proxy</see> and <see cref="SyndicationResourceLoadSettings"/>. /// </summary> /// <param name="source">A <see cref="Uri"/> that points to the location of the web resource used to load the syndication resource.</param> /// <param name="options">A <see cref="WebRequestOptions"/> that holds options that should be applied to web requests.</param> /// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> object used to configure the <see cref="AtomEntry"/> instance. This value can be <b>null</b>.</param> /// <remarks> /// <para> /// <list type="bullet"> /// <item> /// <description> /// If <paramref name="settings"/> has a <see cref="SyndicationResourceLoadSettings.CharacterEncoding">character encoding</see> of <see cref="System.Text.Encoding.UTF8"/> /// the character encoding of the <paramref name="source"/> will be attempt to be determined automatically, otherwise the specified character encoding will be used. /// If automatic detection fails, a character encoding of <see cref="System.Text.Encoding.UTF8"/> is used by default. /// </description> /// </item> /// <item> /// <description> /// After the load operation has successfully completed, the <see cref="AtomEntry.Loaded"/> event will be raised. /// </description> /// </item> /// </list> /// </para> /// </remarks> /// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="FormatException">The <paramref name="source"/> data does not conform to the expected syndication content format. In this case, the entry remains empty.</exception> /// <exception cref="XmlException">There is a load or parse error in the XML. In this case, the entry remains empty.</exception> public new void Load(Uri source, WebRequestOptions options, SyndicationResourceLoadSettings settings) { //------------------------------------------------------------ // Load syndication resource using base entry implementation //------------------------------------------------------------ base.Load(source, options, settings); //------------------------------------------------------------ // Extract member resource information from extensions //------------------------------------------------------------ AtomPublishingEditedSyndicationExtension editedExtension = this.FindExtension(AtomPublishingEditedSyndicationExtension.MatchByType) as AtomPublishingEditedSyndicationExtension; if (editedExtension != null) { this.EditedOn = editedExtension.Context.EditedOn; } AtomPublishingControlSyndicationExtension controlExtension = this.FindExtension(AtomPublishingControlSyndicationExtension.MatchByType) as AtomPublishingControlSyndicationExtension; if (controlExtension != null) { this.IsDraft = controlExtension.Context.IsDraft; } }
public Task PopulateRequestsAsync() { return(this.Requests.Where(x => x.RequestBody == null).ForEachThrottledAsync(async x => { try { var req = new WebRequestOptions(); foreach (var header in x.RequestHeaders) { req.AddHeader(header.Key, header.Value); } using (var resp = await new LazyUri(x.Url).GetResponseAsync(req)) { using (var sr = new StreamReader(await resp.Content.ReadAsStreamAsync())) { x.ResponseBody = await sr.ReadToEndAsync(); } } } catch (Exception) { } }, 1)); }
/// <summary> /// Initializes a new <see cref="WebRequest"/> suitable for sending a remote procedure call using the supplied host, user agent, message, credentials, and proxy. /// </summary> /// <param name="host">A <see cref="Uri"/> that represents the URL of the host computer used for XML-RPC transactions.</param> /// <param name="userAgent">Information such as the application name, version, host operating system, and language.</param> /// <param name="message">A <see cref="XmlRpcMessage"/> that represents the information needed to execute the remote procedure call.</param> /// <param name="useDefaultCredentials"> /// Controls whether the <see cref="CredentialCache.DefaultCredentials">DefaultCredentials</see> are sent when making remote procedure calls. /// </param> /// <param name="options">A <see cref="WebRequestOptions"/> that holds options that should be applied to web requests.</param> /// <exception cref="ArgumentNullException">The <paramref name="host"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="userAgent"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="userAgent"/> is an empty string.</exception> /// <exception cref="ArgumentNullException">The <paramref name="message"/> is a null reference (Nothing in Visual Basic).</exception> private static WebRequest CreateWebRequest(Uri host, string userAgent, XmlRpcMessage message, bool useDefaultCredentials, WebRequestOptions options) { HttpWebRequest httpRequest = null; byte[] payloadData; Guard.ArgumentNotNull(host, "host"); Guard.ArgumentNotNullOrEmptyString(userAgent, "userAgent"); Guard.ArgumentNotNull(message, "message"); using (MemoryStream stream = new MemoryStream()) { XmlWriterSettings settings = new XmlWriterSettings(); settings.ConformanceLevel = ConformanceLevel.Document; settings.Encoding = message.Encoding; settings.Indent = true; settings.OmitXmlDeclaration = false; using (XmlWriter writer = XmlWriter.Create(stream, settings)) { message.WriteTo(writer); writer.Flush(); } stream.Seek(0, SeekOrigin.Begin); payloadData = message.Encoding.GetBytes((new StreamReader(stream)).ReadToEnd()); } httpRequest = (HttpWebRequest)HttpWebRequest.Create(host); httpRequest.Method = "POST"; httpRequest.ContentLength = payloadData.Length; httpRequest.ContentType = String.Format(null, "text/xml; charset={0}", message.Encoding.WebName); httpRequest.UserAgent = userAgent; if (options != null) { options.ApplyOptions(httpRequest); } if (useDefaultCredentials) { httpRequest.Credentials = CredentialCache.DefaultCredentials; } using (Stream stream = httpRequest.GetRequestStream()) { stream.Write(payloadData, 0, payloadData.Length); } return(httpRequest); }
internal static async Task <HttpResponseInfo> SendAsync(this LazyUri url, WebRequestOptions options, HttpRequestMessageBox messageBox, bool alwaysCatchAndForbidRedirects = false, bool keepResponseAliveOnError = false, bool synchronous = false) { HttpUtils.EnsureInitialized(); if (!synchronous) { await Utils.CheckLocalFileAccessAsync(url); } Utils.RaiseWebRequestEvent(url, false); HttpResponseMessage result = null; LazyUri previousResponse2 = null; try { if (options == WebRequestOptions.DefaultOptions) { throw new ArgumentException(); } if (options.WaitBefore.Ticks != 0 && !synchronous) { await TaskEx.Delay(options.WaitBefore); } LazyUri previousResponse1 = null; previousResponse2 = url.Clone(); previousResponse2 = MaybeAddAdditionalQueryParameters(previousResponse2, options); var redirectIndex = 0; while (true) { #if WEBCLIENT HttpContent requestContent = null; #endif var message = messageBox?.PrebuiltRequest ?? CreateRequestInternal(previousResponse2, options, true, redirectIndex #if WEBCLIENT , out requestContent #endif ); if (messageBox != null) { messageBox.Dispose(); messageBox.Message = message; } #if WEBCLIENT if (requestContent != null) { if (requestContent.ContentType != null) { message.ContentType = requestContent.ContentType; } if (requestContent.ContentDisposition != null) { message.Headers["Content-Disposition"] = requestContent.ContentDisposition; } using (var req = await message.GetRequestStreamAsync()) { await requestContent.CopyToAsync(req); } } result = (HttpWebResponse)await message.GetResponseAsync(); #else message.Properties["ShamanURL"] = url; if (options.CustomHttpClient != null) { result = await options.CustomHttpClient.SendAsync(message, HttpCompletionOption.ResponseHeadersRead); } else { if (defaultHttpClient == null) { defaultHttpClient = CreateHttpClient(); } result = messageBox?.PrebuiltResponse ?? await defaultHttpClient.SendAsync(message, HttpCompletionOption.ResponseHeadersRead); } #endif #if !WEBCLIENT if (result.Content != null && result.Content.Headers.ContentType != null && result.Content.Headers.ContentType.CharSet == "utf8") { result.Content.Headers.ContentType.CharSet = "utf-8"; } #endif if ((int)result.StatusCode >= 400) { if (!keepResponseAliveOnError) { result.Dispose(); } // Hackish, change purpose of enumeration type throw new WebException("The web server returned: " + result.StatusCode.ToString(), (WebExceptionStatus)result.StatusCode); } #if WEBCLIENT var zz = result.Headers["Location"]; var redirectUrlNative = zz != null?HttpUtils.GetAbsoluteUri(url.PathConsistentUrl, zz) : null; #else var redirectUrlNative = result.Headers.Location; #endif if (redirectUrlNative == null) { return(new HttpResponseInfo() { RespondingUrl = previousResponse2, Response = result }); } else { if (alwaysCatchAndForbidRedirects) { return new HttpResponseInfo() { Response = result, RespondingUrl = previousResponse2, Exception = new WebException("Unexpected redirect", HttpUtils.Error_UnexpectedRedirect) } } ; result.Dispose(); var redirectUrl = new LazyUri(redirectUrlNative); if (!redirectUrl.IsAbsoluteUri) { redirectUrl = new LazyUri(new Uri(previousResponse2.PathConsistentUrl, redirectUrlNative)); } if (options != null && !options.AllowRedirects) { throw new WebException("Unexpected redirect was received.", HttpUtils.Error_UnexpectedRedirect); } if (redirectIndex == Configuration_MaximumNumberOfRedirects) { throw new WebException("The maximum number of redirects has been reached.", HttpUtils.Error_MaximumNumberOfRedirectsExceeded); } if (!(redirectIndex == 0 && options != null && (options.PostData != null || options.PostString != null))) { if (( (previousResponse1 != null && HttpUtils.UrisEqual(redirectUrl.PathAndQueryConsistentUrl, previousResponse1.PathAndQueryConsistentUrl)) || HttpUtils.UrisEqual(redirectUrl, previousResponse2))) { if (url.GetFragmentParameter("$allow-same-redirect") == "1") { if (!synchronous) { #if NET35 await TaskEx.Delay(Configuration_SameRedirectDelayTimeMs); #else await Task.Delay(Configuration_SameRedirectDelayTimeMs); #endif } } else { throw new WebException("The server isn't redirecting the requested resource properly.", HttpUtils.Error_RedirectLoopDetected); } } } previousResponse1 = previousResponse2; previousResponse2 = redirectUrl; redirectIndex++; } } } catch (Exception ex) { var orig = ex; #if !WEBCLIENT var hre = ex as HttpRequestException; if (hre != null && hre.InnerException != null) { ex = hre.InnerException; } #endif if (alwaysCatchAndForbidRedirects) { return new HttpResponseInfo() { Exception = ex, Response = result, RespondingUrl = previousResponse2 } } ; else if (ex == orig) { throw; } else { throw ex.Rethrow(); } } }
/// <summary> /// Called when a corresponding asynchronous load operation completes. /// </summary> /// <param name="result">The result of the asynchronous operation.</param> private static void AsyncLoadCallback(IAsyncResult result) { System.Text.Encoding encoding = System.Text.Encoding.UTF8; XPathNavigator navigator = null; WebRequest httpWebRequest = null; AtomEntryResource entry = null; Uri source = null; WebRequestOptions options = null; SyndicationResourceLoadSettings settings = null; if (result.IsCompleted) { object[] parameters = (object[])result.AsyncState; httpWebRequest = parameters[0] as WebRequest; entry = parameters[1] as AtomEntryResource; source = parameters[2] as Uri; settings = parameters[3] as SyndicationResourceLoadSettings; options = parameters[4] as WebRequestOptions; object userToken = parameters[5]; if (entry != null) { WebResponse httpWebResponse = (WebResponse)httpWebRequest.EndGetResponse(result); using (Stream stream = httpWebResponse.GetResponseStream()) { if (settings != null) { encoding = settings.CharacterEncoding; } using (StreamReader streamReader = new StreamReader(stream, encoding)) { XmlReaderSettings readerSettings = new XmlReaderSettings(); readerSettings.IgnoreComments = true; readerSettings.IgnoreWhitespace = true; readerSettings.DtdProcessing = DtdProcessing.Ignore; using (XmlReader reader = XmlReader.Create(streamReader, readerSettings)) { if (encoding == System.Text.Encoding.UTF8) { navigator = SyndicationEncodingUtility.CreateSafeNavigator(source, options, null); } else { navigator = SyndicationEncodingUtility.CreateSafeNavigator(source, options, settings.CharacterEncoding); } SyndicationResourceAdapter adapter = new SyndicationResourceAdapter(navigator, settings); adapter.Fill(entry, SyndicationContentFormat.Atom); AtomPublishingEditedSyndicationExtension editedExtension = entry.FindExtension(AtomPublishingEditedSyndicationExtension.MatchByType) as AtomPublishingEditedSyndicationExtension; if (editedExtension != null) { entry.EditedOn = editedExtension.Context.EditedOn; } AtomPublishingControlSyndicationExtension controlExtension = entry.FindExtension(AtomPublishingControlSyndicationExtension.MatchByType) as AtomPublishingControlSyndicationExtension; if (controlExtension != null) { entry.IsDraft = controlExtension.Context.IsDraft; } entry.OnEntryLoaded(new SyndicationResourceLoadedEventArgs(navigator, source, options, userToken)); } } } entry.LoadOperationInProgress = false; } } }
public object MakeWebRequestEx(object apiUrl, object apiMethod, dynamic options, dynamic values) { if (!(apiUrl is string apiUrlText)) { throw new ApplicationException($"{nameof(MakeWebRequestEx)}: {nameof(apiUrl)} must be a string"); } if (!(apiMethod is string apiMethodText)) { throw new ApplicationException($"{nameof(MakeWebRequestEx)}: {nameof(apiMethod)} must be a string"); } int tries = 0; int dnsAttempts = 1; WebRequestOptions webRequestOptions = ProcessWebRequestOptions(options); do { logger.InfoFormat("Script: Calling web url: {0}", apiUrlText); Uri uri = new Uri(apiUrlText); // Makes sure the url is valid try { // Using older WebClient class since it has non-async methods. // We can't use Async calls here because we aren't passing the async/await context through javscript. // That requires using the javascript callback method and makes the javascript more complex. using (WebClientEx wc = new WebClientEx(webRequestOptions.Timeout)) { // fix for possible performance issue with WebClient class // https://stackoverflow.com/questions/4932541/c-sharp-webclient-acting-slow-the-first-time wc.Proxy = null; Stopwatch sw = new Stopwatch(); sw.Start(); if (DummyMode) { wc.Headers.Add("X-DummyMode", "True"); } // Add headers if (webRequestOptions.Headers != null) { foreach (var header in webRequestOptions.Headers) { wc.Headers.Add(header.Key, header.Value?.ToString()); } } string response; if (apiMethodText.Equals("GET", StringComparison.OrdinalIgnoreCase)) { response = wc.DownloadString(uri); } else { string data = null; if (webRequestOptions.KeepRequestAsString) { data = values; } else { var native = ConvertToNative(values); if (native != null) { data = JsonConvert.SerializeObject(native); } } logger.DebugFormat("Script: Request: {0}", data); response = wc.UploadString(uri, apiMethodText, data); } logger.DebugFormat("Script: Response: {0}", response); sw.Stop(); var elapsedTime = sw.Elapsed.TotalSeconds; if ((ChatConfiguration.DefaultRestAPIWarnSendTime >= 0) && (elapsedTime > ChatConfiguration.DefaultRestAPIWarnSendTime)) { logger.WarnFormat("Network: MakeWebRequestEx() took {0} seconds. Url: {1}", elapsedTime, uri); } if (webRequestOptions.KeepResponseAsString) { return(response); } var result = JsonConvert.DeserializeObject <dynamic>(response); return(ScriptHelpers.ToScriptValue(result, ScriptContext)); } } catch (WebException ex) { if (ex.Status == WebExceptionStatus.NameResolutionFailure) { // WebClient gets DNS failures sometimes, so we auto retry. if (++dnsAttempts <= MaxDnsAttempts) { logger.WarnFormat("Script: Warning DNS failure. Retrying: {0}", apiUrl); // dont count as regulare try tries--; continue; } logger.ErrorFormat("Script: Error calling url {0}. {1}, {2}", apiUrl, ex.Status, ex.ToString()); return(null); } logger.ErrorFormat("Script: Error calling url {0}. {1}, {2}", apiUrl, ex.Status, ex.ToString()); if (ex.Status == WebExceptionStatus.ProtocolError) { var webResponse = (HttpWebResponse)ex.Response; var errorBody = new StreamReader(webResponse.GetResponseStream()).ReadToEnd(); logger.DebugFormat("Script: Error Response: {0}", errorBody); if (((int)webResponse.StatusCode >= 400) && ((int)webResponse.StatusCode <= 499)) { // log 400 error. not re-try-able); break; } } } } while (tries++ < webRequestOptions.Retries); return(null); }
private static HttpRequestMessage CreateRequestInternal(LazyUri url, WebRequestOptions options, bool forceSameUrl, int redirectionIndex #if WEBCLIENT , out HttpContent requestContent #endif ) { if (!forceSameUrl) url = MaybeAddAdditionalQueryParameters(url, options); #if WEBCLIENT var message = (HttpWebRequest)WebRequest.Create(url.PathAndQueryConsistentUrl); message.CachePolicy = new System.Net.Cache.RequestCachePolicy(System.Net.Cache.RequestCacheLevel.NoCacheNoStore); message.AutomaticDecompression = DecompressionMethods.Deflate | DecompressionMethods.Deflate; requestContent = null; #else var message = new HttpRequestMessage(); message.RequestUri = url.PathAndQueryConsistentUrl; #endif if (options != null) { if (redirectionIndex != 0) message.Method = HttpMethod.Get; else if (options._method != null) #if WEBCLIENT message.Method = options._method; #else message.Method = new HttpMethod(options._method); #endif else message.Method = (options.PostData != null || options.PostString != null || options.WriteRequest != null) ? HttpMethod.Post : HttpMethod.Get; }
internal static async Task<HttpResponseInfo> SendAsync(this LazyUri url, WebRequestOptions options, HttpRequestMessageBox messageBox, bool alwaysCatchAndForbidRedirects = false, bool keepResponseAliveOnError = false) { await Utils.CheckLocalFileAccessAsync(url); Utils.RaiseWebRequestEvent(url, true); HttpResponseMessage result = null; LazyUri previousResponse2 = null; try { if (options == WebRequestOptions.DefaultOptions) throw new ArgumentException(); if (options.WaitBefore.Ticks != 0) await TaskEx.Delay(options.WaitBefore); LazyUri previousResponse1 = null; previousResponse2 = url.Clone(); previousResponse2 = MaybeAddAdditionalQueryParameters(previousResponse2, options); var redirectIndex = 0; while (true) { #if WEBCLIENT HttpContent requestContent; #endif var message = CreateRequestInternal(previousResponse2, options, true, redirectIndex #if WEBCLIENT , out requestContent #endif ); if (messageBox != null) { messageBox.Dispose(); messageBox.Message = message; } #if WEBCLIENT if(requestContent != null) { if(requestContent.ContentType != null) message.ContentType = requestContent.ContentType; if(requestContent.ContentDisposition != null) message.Headers["Content-Disposition"] = requestContent.ContentDisposition; using(var req = await message.GetRequestStreamAsync()) { await requestContent.CopyToAsync(req); } } result = (HttpWebResponse)await message.GetResponseAsync(); #else var client = CreateHttpClient(); result = await client.SendAsync(message, HttpCompletionOption.ResponseHeadersRead); #endif #if !WEBCLIENT if (result.Content != null && result.Content.Headers.ContentType != null && result.Content.Headers.ContentType.CharSet == "utf8") result.Content.Headers.ContentType.CharSet = "utf-8"; #endif if ((int)result.StatusCode >= 400) { if(!keepResponseAliveOnError) result.Dispose(); // Hackish, change purpose of enumeration type throw new WebException("The web server returned: " + result.StatusCode.ToString(), (WebExceptionStatus)result.StatusCode); } #if WEBCLIENT var zz = result.Headers["Location"]; var redirectUrlNative = zz != null ? HttpUtils.GetAbsoluteUri(url.PathConsistentUrl, zz) : null; #else var redirectUrlNative = result.Headers.Location; #endif if (redirectUrlNative == null) { return new HttpResponseInfo() { RespondingUrl = previousResponse2, Response = result }; } else { if (alwaysCatchAndForbidRedirects) return new HttpResponseInfo() { Response = result, RespondingUrl = previousResponse2, Exception = new WebException("Unexpected redirect", HttpUtils.UnexpectedRedirect) }; result.Dispose(); var redirectUrl = new LazyUri(redirectUrlNative); if (!redirectUrl.IsAbsoluteUri) redirectUrl = new LazyUri(new Uri(previousResponse2.PathConsistentUrl, redirectUrlNative)); if (options != null && !options.AllowRedirects) throw new WebException("Unexpected redirect was received.", HttpUtils.UnexpectedRedirect); if (redirectIndex == Configuration_MaximumNumberOfRedirects) throw new WebException("The maximum number of redirects has been reached.", HttpUtils.MaximumNumberOfRedirectsExceeded); if (!(redirectIndex == 0 && options != null && (options.PostData != null || options.PostString != null))) if ((previousResponse1 != null && HttpUtils.UrisEqual(redirectUrl.PathAndQueryConsistentUrl, previousResponse1.PathAndQueryConsistentUrl)) || HttpUtils.UrisEqual(redirectUrl, previousResponse2)) throw new WebException("The server isn't redirecting the requested resource properly.", HttpUtils.RedirectLoopDetected); previousResponse1 = previousResponse2; previousResponse2 = redirectUrl; redirectIndex++; } } } catch (Exception ex) { var orig = ex; #if !WEBCLIENT var hre = ex as HttpRequestException; if (hre != null && hre.InnerException != null) ex = hre.InnerException; #endif if (alwaysCatchAndForbidRedirects) return new HttpResponseInfo() { Exception = ex, Response = result, RespondingUrl = previousResponse2 }; else if (ex == orig) throw; else throw ex; } }
public async Task<HttpResponseMessage> GetResponseAsync(long startPosition) { if (partialDownload != null && startPosition == 0) { var c = partialDownload; partialDownload = null; return c; } var options = new WebRequestOptions() { Timeout = 30000, TimeoutSecondRetrialAfterError = 10000, TimeoutStartSecondRetrial = null }; var url = new LazyUri(this.Url); HttpExtensionMethods.ProcessMetaParameters(url, options); if (startPosition != 0) options.AddHeader("Range", "bytes=" + startPosition + "-"); return await HttpExtensionMethods.GetResponseAsync(url, options); //return (await HttpExtensionMethods.SendAsync(url, options, null)).Response; }
/// <summary> /// Loads this <see cref="AtomEntry"/> instance asynchronously using the specified <see cref="Uri"/>, <see cref="SyndicationResourceLoadSettings"/>, <see cref="ICredentials"/>, and <see cref="IWebProxy"/>. /// </summary> /// <param name="source">A <see cref="Uri"/> that represents the URL of the syndication resource XML data.</param> /// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> object used to configure the <see cref="AtomEntry"/> instance. This value can be <b>null</b>.</param> /// <param name="options">A <see cref="WebRequestOptions"/> that holds options that should be applied to web requests.</param> /// <param name="userToken">A user-defined object that is passed to the method invoked when the asynchronous operation completes.</param> /// <remarks> /// <para> /// To receive notification when the operation has completed or the operation has been canceled, add an event handler to the <see cref="AtomEntry.Loaded"/> event. /// You can cancel a <see cref="LoadAsync(Uri, SyndicationResourceLoadSettings, ICredentials, IWebProxy, Object)"/> operation by calling the <see cref="LoadAsyncCancel()"/> method. /// </para> /// <para> /// After calling <see cref="LoadAsync(Uri, SyndicationResourceLoadSettings, ICredentials, IWebProxy, Object)"/>, /// you must wait for the load operation to complete before attempting to load the syndication resource using the <see cref="AtomEntry.LoadAsync(Uri, Object)"/> method. /// </para> /// </remarks> /// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="FormatException">The <paramref name="source"/> data does not conform to the expected syndication content format. In this case, the feed remains empty.</exception> /// <exception cref="InvalidOperationException">This <see cref="AtomEntry"/> has a <see cref="LoadAsync(Uri, SyndicationResourceLoadSettings, ICredentials, IWebProxy, Object)"/> call in progress.</exception> public new void LoadAsync(Uri source, SyndicationResourceLoadSettings settings, WebRequestOptions options, Object userToken) { //------------------------------------------------------------ // Validate parameters //------------------------------------------------------------ Guard.ArgumentNotNull(source, "source"); //------------------------------------------------------------ // Use default settings if none specified by the caller //------------------------------------------------------------ if (settings == null) { settings = new SyndicationResourceLoadSettings(); } //------------------------------------------------------------ // Validate syndication resource state //------------------------------------------------------------ if (this.LoadOperationInProgress) { throw new InvalidOperationException(); } //------------------------------------------------------------ // Indicate that a load operation is in progress //------------------------------------------------------------ this.LoadOperationInProgress = true; //------------------------------------------------------------ // Reset the asynchronous load operation cancelled indicator //------------------------------------------------------------ this.AsyncLoadHasBeenCancelled = false; //------------------------------------------------------------ // Build HTTP web request used to retrieve the syndication resource //------------------------------------------------------------ asyncHttpWebRequest = SyndicationEncodingUtility.CreateWebRequest(source, options); asyncHttpWebRequest.Timeout = Convert.ToInt32(settings.Timeout.TotalMilliseconds, System.Globalization.NumberFormatInfo.InvariantInfo); //------------------------------------------------------------ // Get the async response to the web request //------------------------------------------------------------ object[] state = new object[6] { asyncHttpWebRequest, this, source, settings, options, userToken }; IAsyncResult result = asyncHttpWebRequest.BeginGetResponse(new AsyncCallback(AsyncLoadCallback), state); //------------------------------------------------------------ // Register the timeout callback //------------------------------------------------------------ ThreadPool.RegisterWaitForSingleObject(result.AsyncWaitHandle, new WaitOrTimerCallback(AsyncTimeoutCallback), state, settings.Timeout, true); }
//============================================================ // PRIVATE METHODS //============================================================ #region CreateWebRequest(Uri host, string userAgent, TrackbackMessage message, bool useDefaultCredentials, WebRequestOptions options) /// <summary> /// Initializes a new <see cref="WebRequest"/> suitable for sending an Trackback ping request using the supplied host, user agent, message, credentials, and proxy. /// </summary> /// <param name="host">A <see cref="Uri"/> that represents the URL of the host computer used for Trackback transactions.</param> /// <param name="userAgent">Information such as the application name, version, host operating system, and language.</param> /// <param name="message">A <see cref="TrackbackMessage"/> that represents the information needed to execute the Trackback ping request.</param> /// <param name="useDefaultCredentials"> /// Controls whether the <see cref="CredentialCache.DefaultCredentials">DefaultCredentials</see> are sent when making Trackback pings. /// </param> /// <param name="options">A <see cref="WebRequestOptions"/> that holds options that should be applied to web requests.</param> /// <exception cref="ArgumentNullException">The <paramref name="host"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="userAgent"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="userAgent"/> is an empty string.</exception> /// <exception cref="ArgumentNullException">The <paramref name="message"/> is a null reference (Nothing in Visual Basic).</exception> private static WebRequest CreateWebRequest(Uri host, string userAgent, TrackbackMessage message, bool useDefaultCredentials, WebRequestOptions options) { //------------------------------------------------------------ // Local members //------------------------------------------------------------ HttpWebRequest httpRequest = null; byte[] payloadData; //------------------------------------------------------------ // Validate parameters //------------------------------------------------------------ Guard.ArgumentNotNull(host, "host"); Guard.ArgumentNotNullOrEmptyString(userAgent, "userAgent"); Guard.ArgumentNotNull(message, "message"); //------------------------------------------------------------ // Build the Trackback payload data //------------------------------------------------------------ using (MemoryStream stream = new MemoryStream()) { using (StreamWriter writer = new StreamWriter(stream, message.Encoding)) { message.WriteTo(writer); writer.Flush(); stream.Seek(0, SeekOrigin.Begin); payloadData = message.Encoding.GetBytes((new StreamReader(stream)).ReadToEnd()); } } //------------------------------------------------------------ // Build Trackback web request used to send an Trackback ping request //------------------------------------------------------------ httpRequest = (HttpWebRequest)HttpWebRequest.Create(host); httpRequest.Method = "POST"; httpRequest.ContentLength = payloadData.Length; httpRequest.ContentType = String.Format(null, "application/x-www-form-urlencoded; charset={0}", message.Encoding.WebName); httpRequest.UserAgent = userAgent; if (options != null) { options.ApplyOptions(httpRequest); } if (useDefaultCredentials) { httpRequest.Credentials = CredentialCache.DefaultCredentials; } using (Stream stream = httpRequest.GetRequestStream()) { stream.Write(payloadData, 0, payloadData.Length); } return(httpRequest); }
//============================================================ // CALLBACK DELEGATE METHODS //============================================================ #region AsyncLoadCallback(IAsyncResult result) /// <summary> /// Called when a corresponding asynchronous load operation completes. /// </summary> /// <param name="result">The result of the asynchronous operation.</param> private static void AsyncLoadCallback(IAsyncResult result) { //------------------------------------------------------------ // Local members //------------------------------------------------------------ System.Text.Encoding encoding = System.Text.Encoding.UTF8; XPathNavigator navigator = null; WebRequest httpWebRequest = null; AtomEntryResource entry = null; Uri source = null; WebRequestOptions options = null; SyndicationResourceLoadSettings settings = null; //------------------------------------------------------------ // Determine if the async send operation completed //------------------------------------------------------------ if (result.IsCompleted) { //------------------------------------------------------------ // Extract the send operations parameters from the user state //------------------------------------------------------------ object[] parameters = (object[])result.AsyncState; httpWebRequest = parameters[0] as WebRequest; entry = parameters[1] as AtomEntryResource; source = parameters[2] as Uri; settings = parameters[3] as SyndicationResourceLoadSettings; options = parameters[4] as WebRequestOptions; object userToken = parameters[5]; //------------------------------------------------------------ // Verify expected parameters were found //------------------------------------------------------------ if (entry != null) { //------------------------------------------------------------ // Get the response to the syndication resource request //------------------------------------------------------------ WebResponse httpWebResponse = (WebResponse)httpWebRequest.EndGetResponse(result); //------------------------------------------------------------ // Load syndication resource //------------------------------------------------------------ using (Stream stream = httpWebResponse.GetResponseStream()) { if (settings != null) { encoding = settings.CharacterEncoding; } using (StreamReader streamReader = new StreamReader(stream, encoding)) { XmlReaderSettings readerSettings = new XmlReaderSettings(); readerSettings.IgnoreComments = true; readerSettings.IgnoreWhitespace = true; readerSettings.ProhibitDtd = false; using (XmlReader reader = XmlReader.Create(streamReader, readerSettings)) { if (encoding == System.Text.Encoding.UTF8) { navigator = SyndicationEncodingUtility.CreateSafeNavigator(source, options, null); } else { navigator = SyndicationEncodingUtility.CreateSafeNavigator(source, options, settings.CharacterEncoding); } //------------------------------------------------------------ // Load syndication resource using the framework adapters //------------------------------------------------------------ SyndicationResourceAdapter adapter = new SyndicationResourceAdapter(navigator, settings); adapter.Fill(entry, SyndicationContentFormat.Atom); //------------------------------------------------------------ // Extract member resource information from extensions //------------------------------------------------------------ AtomPublishingEditedSyndicationExtension editedExtension = entry.FindExtension(AtomPublishingEditedSyndicationExtension.MatchByType) as AtomPublishingEditedSyndicationExtension; if (editedExtension != null) { entry.EditedOn = editedExtension.Context.EditedOn; } AtomPublishingControlSyndicationExtension controlExtension = entry.FindExtension(AtomPublishingControlSyndicationExtension.MatchByType) as AtomPublishingControlSyndicationExtension; if (controlExtension != null) { entry.IsDraft = controlExtension.Context.IsDraft; } //------------------------------------------------------------ // Raise Loaded event to notify registered handlers of state change //------------------------------------------------------------ entry.OnEntryLoaded(new SyndicationResourceLoadedEventArgs(navigator, source, options, userToken)); } } } //------------------------------------------------------------ // Reset load operation in progress indicator //------------------------------------------------------------ entry.LoadOperationInProgress = false; } } }
public static T GetJson <T>(this Uri url, WebRequestOptions options = null) { return(DeserializeJson <T>(url.GetString(options))); }
/// <summary> /// Loads the syndication resource from the supplied <see cref="Uri"/> using the specified <see cref="ICredentials">credentials</see> and <see cref="IWebProxy">proxy</see>. /// </summary> /// <param name="source">A <see cref="Uri"/> that points to the location of the web resource used to load the syndication resource.</param> /// <param name="options">A <see cref="WebRequestOptions"/> that holds options that should be applied to web requests.</param> /// <remarks> /// <para> /// <list type="bullet"> /// <item> /// <description> /// After the load operation has successfully completed, the <see cref="MyCustomRssFeed.Loaded"/> event will be raised. /// </description> /// </item> /// </list> /// </para> /// </remarks> /// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="FormatException">The <paramref name="source"/> data does not conform to the expected syndication content format. In this case, the feed remains empty.</exception> /// <exception cref="XmlException">There is a load or parse error in the XML. In this case, the feed remains empty.</exception> public void Load(Uri source, WebRequestOptions options) { this.Load(source, options, null); }