| public BeginGetResponse ( System callback, object state ) : System.IAsyncResult | ||
| callback | System | |
| state | object | |
| return | System.IAsyncResult | |
public void BeginProcessRequest(Site site)
{
string sql = "";
int iResult = 0;
this.Site = site;
oDataIO = new DataIO();
SqlConnection Conn = new SqlConnection();
Conn = oDataIO.GetDBConnection("ProfilesDB");
sqlCmd = new SqlCommand();
sqlCmd.Connection = Conn;
site.IsDone = false;
_request = WebRequest.Create(site.URL);
// Enter log record
sql = "insert into [Direct.].LogOutgoing(FSID,SiteID,Details,SentDate,QueryString) "
+ " values ('" + site.FSID.ToString() + "'," + site.SiteID.ToString() + ",0,GetDate()," + cs(site.SearchPhrase) + ")";
sqlCmd.CommandText = sql;
sqlCmd.CommandType = System.Data.CommandType.Text;
iResult = sqlCmd.ExecuteNonQuery();
if (sqlCmd.Connection.State == System.Data.ConnectionState.Open)
sqlCmd.Connection.Close();
_request.BeginGetResponse(new AsyncCallback(EndProcessRequest), site);
}
private void BingSupportedLanguageCodesFetched(IAsyncResult ar)
{
// Fetched language codes
// Get the request details
HttpWebRequest request = (HttpWebRequest)ar.AsyncState;
// Get the response details
HttpWebResponse response = (HttpWebResponse)request.EndGetResponse(ar);
// Read the contents of the response into a string
System.IO.Stream streamResponse = response.GetResponseStream();
System.IO.StreamReader streamRead = new System.IO.StreamReader(streamResponse);
string langCodes = streamRead.ReadToEnd();
ApplicationData.Current.LocalSettings.Values["supportedLanguageCodes"] = langCodes;
// We have language codes. Fetch the language names as well
try
{
string uriForNames = "http://api.microsofttranslator.com/V2/Ajax.svc/GetLanguageNames?locale=en&languageCodes=" + langCodes;
System.Net.WebRequest translationWebRequest = System.Net.HttpWebRequest.Create(uriForNames);
// The authorization header needs to be "Bearer" + " " + the access token
string headerValue = "Bearer " + AdmAccessToken._admAccessToken.access_token;
translationWebRequest.Headers["Authorization"] = headerValue;
// And now we call the service. When the translation is complete, we'll get the callback
IAsyncResult writeRequestStreamCallback = (IAsyncResult)translationWebRequest.BeginGetResponse(new AsyncCallback(BingSupportedLanguageNamesFetched), translationWebRequest);
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine("Something bad happened while fetching language names" + ex.Message);
}
}
public void Check(string currentVersion, Action<bool, Update[]> callback)
{
responseCallback = callback;
webRequest = WebRequest.Create(string.Format(UpdateUrl, currentVersion));
webRequest.BeginGetResponse(new AsyncCallback(finishRequest), null);
}
IAsyncResult BeginAsyncOperation(object sender, EventArgs e,
AsyncCallback cb, object state)
{
Trace.Write("BeginAsyncOperation");
_request = WebRequest.Create("http://msdn.microsoft.com");
return _request.BeginGetResponse(cb, state);
}
public ImageBrowser()
{
InitializeComponent();
//Get list of stock photos
Uri uri = new Uri("http://docs.xamarin.com/demo/stock.json");
request = WebRequest.Create(uri);
request.BeginGetResponse(WebRequestCallback, null);
}
private async Task StartWebRequest()
{
requester = (HttpWebRequest)WebRequest.Create(url);
requester.BeginGetResponse(new AsyncCallback(FinishWebRequest), null);
GettingData(BEGINDOWNLOAD);
while (!go)
await Task.Delay(500);
GettingData(ENDDOWNLOAD);
}
private void BeginRequest(WebRequest request, AsyncCallback callback, object state)
{
var result = request.BeginGetResponse(callback, state);
ClientEngine.MainLoop.QueueTimeout(RequestTimeout, delegate
{
if (!result.IsCompleted)
request.Abort();
return false;
});
}
public void Get(WebRequest request, Action<HttpStatusCode, Stream> onComplete, Action<Uri, Exception> onError)
{
SetStandardHeaders(request);
request.BeginGetResponse(HandleResponseCallback,
new RequestContext
{
Request = request,
OnComplete = (code, s, entity) => onComplete(code, entity),
OnError = onError,
});
}
private void UploadStringRequestAsyncCallback(IAsyncResult result)
{
try {
object[] bag = (result.AsyncState as object[]);
byte[] data = (bag [0] as byte[]);
Stream stream = request.EndGetRequestStream(result);
stream.Write(data, 0, data.Length);
request.BeginGetResponse(new AsyncCallback(UploadStringResponseAsyncCallback), bag [1]);
}
catch {
request.Abort();
throw;
}
}
internal void WriteStreamClosedCallback(object WebClientData, long length)
{
try
{
request.BeginGetResponse(OpenWriteAsyncResponseCallback, WebClientData);
}
catch (Exception e)
{
callback_data.sync_context.Post(delegate(object sender)
{
OnWriteStreamClosed(new WriteStreamClosedEventArgs(e));
}, null);
}
finally
{
// kind of dummy, 0% progress, that is always emitted
upload_length = length;
callback_data.sync_context.Post(delegate(object sender)
{
OnUploadProgressChanged(
new UploadProgressChangedEventArgs(0, -1, length, -1, 0, callback_data.user_token));
}, null);
}
}
private static void DoWithResponse(WebRequest request, Action<HttpWebResponse> responseAction)
{
Action wrapperAction = () =>
{
request.BeginGetResponse(iar =>
{
var response = (HttpWebResponse)((HttpWebRequest)iar.AsyncState).EndGetResponse(iar);
responseAction(response);
}, request);
};
wrapperAction.BeginInvoke(iar =>
{
var action = (Action)iar.AsyncState;
action.EndInvoke(iar);
}, wrapperAction);
}
public void SearchForPlaceAync(GooglePlaceSearchRequest searchRequest)
{
var language = searchRequest.Language.HasValue ? Enum.GetName(typeof(GoogleMapsLanguage), searchRequest.Language.Value).Replace("_", "-") : null;
var types = searchRequest.Types == null ? string.Empty : string.Join("|", searchRequest.Types);
var requestUrl = string.Format(GooglePlacesAPI_Url, _appId, searchRequest.Sensor.ToString().ToLower(), searchRequest.Keyword);
_webRequest = (HttpWebRequest)HttpWebRequest.Create(requestUrl);
_webRequest.Method = "Post";
try
{
_webRequest.BeginGetResponse(ResponseCallback, new List<object> { _webRequest, searchRequest });
}
catch (Exception e)
{
SearchForPlacesAsyncFailed(e.Message, e);
}
}
private void FetchBingSupportedLanguageCodes()
{
try
{
string uriForCodes = "http://api.microsofttranslator.com/V2/Ajax.svc/GetLanguagesForTranslate";
System.Net.WebRequest translationWebRequest = System.Net.HttpWebRequest.Create(uriForCodes);
// The authorization header needs to be "Bearer" + " " + the access token
string headerValue = "Bearer " + AdmAccessToken._admAccessToken.access_token;
translationWebRequest.Headers["Authorization"] = headerValue;
// And now we call the service. When the translation is complete, we'll get the callback
IAsyncResult writeRequestStreamCallback = (IAsyncResult)translationWebRequest.BeginGetResponse(new AsyncCallback(BingSupportedLanguageCodesFetched), translationWebRequest);
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine("Something bad happened while fetching language codes" + ex.Message);
}
}
private static void RequestAsync(WebRequest request, byte[] bodyBytes, Action<TrackResult> callback)
{
request.BeginGetRequestStream((r1) =>
{
try
{
var stream = request.EndGetRequestStream(r1);
stream.BeginWrite(bodyBytes, 0, bodyBytes.Length, (r2) =>
{
try
{
stream.EndWrite(r2);
stream.Dispose();
request.BeginGetResponse((r3) =>
{
try
{
using (var response = request.EndGetResponse(r3))
{
using (var reader = new StreamReader(response.GetResponseStream()))
{
if (callback != null)
callback(new TrackResult(reader.ReadToEnd()));
}
}
}
catch (Exception ex)
{
HandleError(callback, ex);
}
}, null);
}
catch (Exception ex)
{
HandleError(callback, ex);
}
}, null);
}
catch(Exception ex)
{
HandleError(callback, ex);
}
}, null);
}
private static WebResponse GetResponseInternal(WebRequest request)
{
// build the envent
using (var revent = new ManualResetEvent(false))
{
// start the async call
IAsyncResult result = request.BeginGetResponse(new AsyncCallback(CallStreamCallback), revent);
// wait for event
revent.WaitOne();
// get the response
WebResponse response = request.EndGetResponse(result);
// go ahead
return response;
}
}
public void Execute()
{
MobeelizerConfigurationSection section = (MobeelizerConfigurationSection)ConfigurationManager.GetSection("mobeelizer-configuration");
String propUrl = null;
String mode = null;
try
{
propUrl = section.AppSettings[META_URL].Value;
}
catch (KeyNotFoundException) { }
try
{
mode = section.AppSettings[META_MODE].Value;
}
catch (KeyNotFoundException) { }
StringBuilder baseUrlBuilder = new StringBuilder();
if (propUrl == null)
{
baseUrlBuilder.Append(Resources.Config.c_apiURL_host);
}
else
{
baseUrlBuilder.Append(propUrl);
}
baseUrlBuilder.Append(Resources.Config.c_apiURL_path);
if ("test".Equals(mode.ToLower()))
{
baseUrlBuilder.Append("?test=true");
}
else
{
baseUrlBuilder.Append("?test=false");
}
baseUrlBuilder.Append("&disablecache=" + Guid.NewGuid());
Uri url = new Uri(baseUrlBuilder.ToString());
request = WebRequest.Create(url);
request.BeginGetResponse(OnBeginGetResponse, null);
}
private void SendTranslateViaBingRequest()
{
try
{
string strLngFrom = ApplicationData.Current.LocalSettings.Values["tramslateFromLanguage"].ToString();
string strLngTo = ApplicationData.Current.LocalSettings.Values["tramslateToLanguage"].ToString();
string uri = "http://api.microsofttranslator.com/v2/Http.svc/Translate?text=" + WebUtility.UrlEncode(strTextToTranslate) + "&from=" + strLngFrom + "&to=" + strLngTo;
System.Net.WebRequest translationWebRequest = System.Net.HttpWebRequest.Create(uri);
// The authorization header needs to be "Bearer" + " " + the access token
string headerValue = "Bearer " + AdmAccessToken._admAccessToken.access_token;
translationWebRequest.Headers["Authorization"] = headerValue;
// And now we call the service. When the translation is complete, we'll get the callback
IAsyncResult writeRequestStreamCallback = (IAsyncResult)translationWebRequest.BeginGetResponse(new AsyncCallback(BingTranslationReady), translationWebRequest);
strTextToTranslate = "";
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine("Something bad happened " + ex.Message);
}
}
public Task <byte[]> UploadValuesTaskAsync(string address, NameValueCollection names)
{
return(Task <byte[]> .Factory.StartNew(() =>
{
WebRequest request = this.GetWebRequest(new Uri(address));
request.ContentType = "text/plain; charset=utf-8";
request.Method = "POST";
byte[] data = null;
request.BeginGetRequestStream(new AsyncCallback((IAsyncResult res) =>
{
using (Stream postStream = request.EndGetRequestStream(res))
{
StringBuilder postParamBuilder = new StringBuilder();
foreach (var key in names.Keys)
{
postParamBuilder.Append(String.Format("{0}={1}&", key, names[key]));
}
byte[] byteArray = Encoding.UTF8.GetBytes(postParamBuilder.ToString());
postStream.Write(byteArray, 0, byteArray.Length);
postStream.Close();
request.BeginGetResponse(new AsyncCallback((IAsyncResult nres) =>
{
using (Stream respStream = request.EndGetResponse(nres).GetResponseStream())
{
data = new byte[respStream.Length];
respStream.Write(data, 0, data.Length);
}
}), null);
}
}), null);
while (data == null)
{
}
return data;
}));
}
public void OpenReadAsync(Uri address, object userToken)
{
if (address == null)
{
throw new ArgumentNullException("address");
}
lock (locker) {
SetBusy();
try {
request = SetupRequest(address, "GET", new CallbackData(userToken));
request.BeginGetResponse(new AsyncCallback(OpenReadAsyncCallback), null);
}
catch (Exception e) {
WebException wex = new WebException("Could not start operation.", e);
OnOpenReadCompleted(
new OpenReadCompletedEventArgs(null, wex, false, userToken));
}
}
}
private WebQueryAsyncResult ExecuteGetOrDeleteAsync(ICache cache,
string key,
string url,
WebRequest request,
object userState)
{
var fetch = cache.Get<Stream>(key);
if (fetch != null)
{
var args = new WebQueryResponseEventArgs(fetch);
OnQueryResponse(args);
var result = new WebQueryAsyncResult
{
CompletedSynchronously = true
};
return result;
}
else
{
var state = new Triplet<WebRequest, Pair<ICache, string>, object>
{
First = request,
Second = new Pair<ICache, string>
{
First = cache,
Second = key
},
Third = userState
};
var args = new WebQueryRequestEventArgs(url);
OnQueryRequest(args);
var inner = request.BeginGetResponse(GetAsyncResponseCallback, state);
RegisterAbortTimer(request, inner);
var result = new WebQueryAsyncResult { InnerResult = inner };
return result;
}
}
private void Start()
{
try
{
request = System.Net.WebRequest.Create(requestURI);
request.Proxy = System.Net.GlobalProxySelection.GetEmptyWebProxy();
if (null != postData)
{
request.ContentLength = postData.Length;
request.ContentType = "application/x-www-form-urlencoded";
request.Method = "POST";
request.BeginGetRequestStream(new AsyncCallback(GetRequestCallback), request);
}
else
{
request.Method = "GET";
request.BeginGetResponse(new AsyncCallback(GetResponseCallback), request);
}
}
catch (OutOfMemoryException e)
{
if (retryCount < retryMax)
{
System.Diagnostics.Debug.WriteLine(e.Message);
++retryCount;
Random random = new Random();
Thread.Sleep(retryDelay * random.Next(retryCount * retryCount));
Start();
}
else
{
OnException(e);
}
}
catch (Exception e)
{
OnException(e);
}
}
private void GetResponseCallback(IAsyncResult ar)
{
HttpWebRequest request = (HttpWebRequest)ar.AsyncState;
HttpWebResponse response = (HttpWebResponse)request.EndGetResponse(ar);
try
{
System.Runtime.Serialization.Json.DataContractJsonSerializer serializer = new
System.Runtime.Serialization.Json.DataContractJsonSerializer(typeof(AdmAccessToken));
AdmAccessToken token =
(AdmAccessToken)serializer.ReadObject(response.GetResponseStream());
string uri = "http://api.microsofttranslator.com/v2/Http.svc/Translate?text=" + System.Net.HttpUtility.UrlEncode(strTextToTranslate) + "&from=" + strLngFrom + "&to=" + strLngTo;
System.Net.WebRequest translationWebRequest = System.Net.HttpWebRequest.Create(uri);
string headerValue = "Bearer " + token.access_token;
translationWebRequest.Headers["Authorization"] = headerValue;
IAsyncResult writeRequestStreamCallback = (IAsyncResult)translationWebRequest.BeginGetResponse(new AsyncCallback(translationReady), translationWebRequest);
}
catch (Exception ex)
{
}
}
private void ButtonSearch_Click(object sender, RoutedEventArgs e)
{
if (NetworkInterface.NetworkInterfaceType != NetworkInterfaceType.None)
{
if (BookToSearch.Text.Equals("") || BookToSearch.Text == "" || BookToSearch.Text == null)
{
MessageBox.Show("请输入需要搜索的书名或者关键字！");
}
else
{
string BookTitle = BookToSearch.Text;
string url = @"http://api.douban.com/v2/book/search?q=" + @BookTitle; //get book info from douban.com
downDelegate = setConent;
System.Net.WebRequest request = HttpWebRequest.Create(url);
IAsyncResult result = (IAsyncResult)request.BeginGetResponse(ResponseCallback, request); //async web request
}
}
else
{
Debug.WriteLine("[DEBUG]Network Interface Available Status:" + NetworkInterface.GetIsNetworkAvailable());
Debug.WriteLine("[DEBUG]Network Interface Type Status:" + NetworkInterface.NetworkInterfaceType);
MessageBox.Show("搜索书籍信息需要网络连接，请开启手机的移动网络。");
}
}
private void OnGetRequestStreamCompleted(IAsyncResult ar, WebRequest request, byte[] data)
{
Debug.Assert(ar != null);
Debug.Assert(request != null);
Debug.Assert(data != null);
Debug.Assert(data.Length > 0);
try
{
using (var output = request.EndGetRequestStream(ar))
output.Write(data, 0, data.Length);
request.BeginGetResponse(OnGetResponseCompleted, request);
}
catch (Exception e)
{
OnWebPostError(request, e);
}
}
private void HandleResponse(WebRequest request)
{
WebResponse response = null;
Stream responseStream = null;
StreamReader responseStreamReader = null;
request.BeginGetResponse((responseResult) =>
{
try
{
response = request.EndGetResponse(responseResult);
responseStream = response.GetResponseStream();
responseStreamReader = new StreamReader(responseStream);
ResponseText = responseStreamReader.ReadToEnd();
}
finally
{
try { if (response != null) response.Dispose(); }
catch { }
try { if (responseStream != null) responseStream.Dispose(); }
catch { }
try { if (responseStreamReader != null) ((IDisposable)responseStreamReader).Dispose(); }
catch { }
DisableProgressIndicator();
}
}, null);
}
public void OpenReadAsync (Uri address, object userToken)
{
if (address == null)
throw new ArgumentNullException ("address");
lock (locker) {
SetBusy ();
try {
request = SetupRequest (address, "GET", new CallbackData (userToken));
request.BeginGetResponse (new AsyncCallback (OpenReadAsyncCallback), null);
}
catch (Exception e) {
WebException wex = new WebException ("Could not start operation.", e);
OnOpenReadCompleted (
new OpenReadCompletedEventArgs (null, wex, false, userToken));
}
}
}
public void SendRequest()
{
try
{
Request = WebRequest.Create(Url);
Request.Method = HttpMethod;
Request.ContentType = HttpMIMEType;
if (!HttpVerifyCert)
{
// We could hijack Connection Group Name to identify
// a desired security exception. But at the moment we'll use a dummy header instead.
// Request.ConnectionGroupName = "NoVerify";
Request.Headers.Add("NoVerifyCert", "true");
}
// else
// {
// Request.ConnectionGroupName="Verify";
// }
if (!HttpPragmaNoCache)
{
Request.Headers.Add("Pragma", "no-cache");
}
if (HttpCustomHeaders != null)
{
for (int i = 0; i < HttpCustomHeaders.Count; i += 2)
Request.Headers.Add(HttpCustomHeaders[i],
HttpCustomHeaders[i+1]);
}
if (!string.IsNullOrEmpty(proxyurl))
{
if (!string.IsNullOrEmpty(proxyexcepts))
{
string[] elist = proxyexcepts.Split(';');
Request.Proxy = new WebProxy(proxyurl, true, elist);
}
else
{
Request.Proxy = new WebProxy(proxyurl, true);
}
}
if (ResponseHeaders != null)
{
foreach (KeyValuePair<string, string> entry in ResponseHeaders)
if (entry.Key.ToLower().Equals("user-agent") && Request is HttpWebRequest)
((HttpWebRequest)Request).UserAgent = entry.Value;
else
Request.Headers[entry.Key] = entry.Value;
}
// Encode outbound data
if (!string.IsNullOrEmpty(OutboundBody))
{
byte[] data = Util.UTF8.GetBytes(OutboundBody);
Request.ContentLength = data.Length;
using (Stream bstream = Request.GetRequestStream())
bstream.Write(data, 0, data.Length);
}
try
{
IAsyncResult result = (IAsyncResult)Request.BeginGetResponse(ResponseCallback, null);
ThreadPool.RegisterWaitForSingleObject(
result.AsyncWaitHandle, new WaitOrTimerCallback(TimeoutCallback), null, HttpTimeout, true);
}
catch (WebException e)
{
if (e.Status != WebExceptionStatus.ProtocolError)
{
throw;
}
HttpWebResponse response = (HttpWebResponse)e.Response;
Status = (int)response.StatusCode;
ResponseBody = response.StatusDescription;
_finished = true;
}
}
catch (Exception e)
{
// m_log.Debug(
// string.Format("[SCRIPTS HTTP REQUESTS]: Exception on request to {0} for {1} ", Url, ItemID), e);
Status = (int)OSHttpStatusCode.ClientErrorJoker;
ResponseBody = e.Message;
_finished = true;
}
}
private static Task<HttpWebResponse> GetResponseWithRetryAsync(WebRequest request, int retries)
{
if (retries < 0)
throw new ArgumentOutOfRangeException("Invalid number of retries to make");
Func<Task<WebResponse>, Task<HttpWebResponse>> proceedToNextStep = null;
Func<Task<HttpWebResponse>> doStep = () =>
{
var ds = Task.Factory.FromAsync(
(asyncCallback, state) => request.BeginGetResponse(asyncCallback, state),
(asyncResult) => request.EndGetResponse(asyncResult),
null
);
return ds.ContinueWith(proceedToNextStep).Unwrap();
};
proceedToNextStep = (prevTask) =>
{
if (prevTask.IsCanceled)
throw new TaskCanceledException();
if (prevTask.IsFaulted && --retries > 0)
return doStep();
var tcs = new TaskCompletionSource<HttpWebResponse>();
tcs.SetResult((HttpWebResponse)prevTask.Result);
return tcs.Task;
};
return doStep();
}
internal virtual WebResponse GetResponse(WebRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
HttpWebRequest request2 = request as HttpWebRequest;
TimeoutState state = null;
if ((request2 != null) && (request2.Timeout > 0))
{
state = new TimeoutState(request2);
}
this._webRequest = request;
WebRequestState state2 = new WebRequestState(request);
IAsyncResult result = request.BeginGetResponse(new AsyncCallback(WebRequestPSCmdlet.ResponseCallback), state2);
if (state != null)
{
ThreadPool.RegisterWaitForSingleObject(result.AsyncWaitHandle, new WaitOrTimerCallback(WebRequestPSCmdlet.TimeoutCallback), state, state.httpRequest.Timeout, true);
}
state2.waithandle.WaitOne(-1, false);
this._webRequest = null;
if (state2.webException == null)
{
return state2.response;
}
if (((state != null) && state.abort) && state2.webException.Status.Equals(WebExceptionStatus.RequestCanceled))
{
throw new WebException(WebCmdletStrings.RequestTimeout, WebExceptionStatus.Timeout);
}
throw state2.webException;
}
private void OnGetRequestStreamCompleted(IAsyncResult ar, WebRequest request, byte[] data)
{
try {
using (var output = request.EndGetRequestStream(ar)) {
output.Write(data, 0, data.Length);
}
request.BeginGetResponse(OnGetResponseCompleted, request);
}
catch (Exception e) {
OnWebPostError(request, e);
}
}
/// <summary>
/// Begins download process.
/// </summary>
public void Download()
{
_downloadStatus.ProgressBar.Information = Languages.AppResources.downloadNewSurveys_Downloading;
_downloadStatus.ProgressBar.IsEnabled = true;
_downloadStatus.CanCancel = true;
_downloadStatus.IsCanceled = false;
try
{
_request = WebRequest.Create(_downloadUrl);
var result = (IAsyncResult)_request.BeginGetResponse(DownloadCallback, _request);
}
catch (WebException)
{
_downloadStatus.Message.Show(Languages.AppResources.downloadNewSurveys_CantDownloading);
}
}
private HttpWebResponse SmartGetWebResponse(WebRequest req)
{
try
{
if (req == null)
return null;
IAsyncResult arGet = req.BeginGetResponse(null, null);
if (!arGet.AsyncWaitHandle.WaitOne(DEFAULT_READ_TIMEOUT))
{
return null;
}
return req.EndGetResponse(arGet) as HttpWebResponse;
}
catch (Exception ex)
{
bool bShouldLog = true;
WebException exw = ex as WebException;
if (exw != null)
{
if (exw.Status == WebExceptionStatus.RequestCanceled)
{
bShouldLog = false;
}
else if (exw.Status == WebExceptionStatus.ProtocolError)
{
try
{
System.Net.HttpWebResponse httpRes = exw.Response as System.Net.HttpWebResponse;
if (httpRes != null && httpRes.StatusCode == HttpStatusCode.NotFound)
{
SetFeedActive(false, false);
FirePropertyChangedAction(false);
LongSmartSleep(FEED_NOT_ACTIVE_SLEEP_SECS, "SmartGetWebResponse - Inactive Stream (404)"); // sleeping for 15 minutes on this stream!
}
}
catch { }
}
}
if (bShouldLog)
{
Common.DebugHelper.WriteExceptionToLog("WaveStreamProcessor.SmartGetWebResponse", ex, false, _streamURL);
}
return null;
}
}
internal AsyncMetadataLocationRetriever(WebRequest request, long maxMessageSize, XmlDictionaryReaderQuotas readerQuotas, TimeoutHelper timeoutHelper, AsyncCallback callback, object state)
: base(callback, state)
{
this.maxMessageSize = maxMessageSize;
this.readerQuotas = readerQuotas;
IAsyncResult result = request.BeginGetResponse(Fx.ThunkCallback(new AsyncCallback(this.GetResponseCallback)), request);
//Register a callback to abort the request if we hit the timeout.
ThreadPool.RegisterWaitForSingleObject(result.AsyncWaitHandle,
Fx.ThunkCallback(new WaitOrTimerCallback(RetrieveTimeout)), request,
TimeoutHelper.ToMilliseconds(timeoutHelper.RemainingTime()), /* executeOnlyOnce */ true);
if (result.CompletedSynchronously)
{
HandleResult(result);
this.Complete(true);
}
}
public IPAddressAsyn(string url, int millisecondsTimeout)
{
WebRequest = WebRequest.Create(url);
WebRequest.Timeout = millisecondsTimeout;
WebRequest.BeginGetResponse(GetResponseCallback, null);
}
public override IAsyncResult BeginGetResponse(AsyncCallback callback, object state)
{
return(_internalWebRequest.BeginGetResponse(callback, state));
}
/// <summary>
/// Loads this <see cref="RssFeed"/> 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="RssFeed"/> 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="RssFeed"/> 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)
{
//------------------------------------------------------------
// 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);
}
public void requestFrame()
{
request = System.Net.HttpWebRequest.Create(cameraUrl);
request.Credentials = new NetworkCredential("admin", "12345");
request.Proxy = null;
request.BeginGetResponse(OnfinishRequestFrame, request);
}
private void _IrosHPost(IntPtr handle, ref IrosHPostData data)
{
string url = Marshal.PtrToStringAnsi(data.url);
string ctype = Marshal.PtrToStringAnsi(data.contentType);
System.Net.WebRequest req = System.Net.WebRequest.Create(url);
req.ContentType = ctype;
//req.Method = data.len > 0 ? "POST" : "GET";
req.Method = "POST";
TraceLogger(String.Format("{3}ing {2} bytes to {0} handle {1}", url, handle, data.len, req.Method));
byte[] buffer = new byte[data.len];
Marshal.Copy(data.data, buffer, 0, buffer.Length);
WebTask t = new WebTask()
{
Req = req, Handle = handle, writeBack = data.writeBack
};
_http[handle] = t;
AsyncCallback doResponse = ar2 => {
try {
var resp = req.EndGetResponse(ar2);
var rs = req.GetResponse().GetResponseStream();
t.Async = rs.BeginRead(t.ReceiveBuffer, 0, t.ReceiveBuffer.Length, AsyncReceive, t);
} catch (WebException e) {
ErrorLogger(String.Format("Error receiving from {0}: {1}", handle, e.ToString()));
t.ReceiveDone = true;
if (e.Response != null)
{
t.Status = (int)((HttpWebResponse)e.Response).StatusCode;
}
else
{
t.Status = 500;
}
}
catch (Exception e)
{
ErrorLogger(String.Format("Error receiving from {0}: {1}", handle, e.ToString()));
t.ReceiveDone = true;
t.Status = 500;
}
};
t.ReceiveBuffer = new byte[0x10000];
if (buffer.Length > 0)
{
t.Async = req.BeginGetRequestStream(ar => {
var s = req.EndGetRequestStream(ar);
using (s) {
s.Write(buffer, 0, buffer.Length);
}
t.Completed = t.Size = buffer.Length;
TraceLogger(String.Format("Beginning GetResponse for {0}", handle));
t.Async = req.BeginGetResponse(doResponse, t);
}, t);
}
else
{
TraceLogger(String.Format("Beginning GetResponse [no request data] for {0}", handle));
t.Async = req.BeginGetResponse(doResponse, t);
}
}
public byte[] Download(WebRequest req, UpdateProgessCallback progressCB)
{
// Ensure flag set correctly.
allDone.Reset();
// Create the state object.
DownloadInfo info = new DownloadInfo();
// Put the request into the state object so it can be passed around.
info.Request = req;
// Assign the callbacks
info.ProgressCallback += progressCB;
// Issue the async request.
IAsyncResult r = (IAsyncResult)req.BeginGetResponse(new AsyncCallback(ResponseCallback), info);
// Wait until the ManualResetEvent is set so that the application
// does not exit until after the callback is called.
allDone.WaitOne();
// Pass back the downloaded information.
if (info.useFastBuffers)
return info.dataBufferFast;
else
{
byte[] data = new byte[info.dataBufferSlow.Count];
for (int b = 0; b < info.dataBufferSlow.Count; b++)
data[b] = (byte)info.dataBufferSlow[b];
return data;
}
}
private void IGrabShardList()
{
fShardReq = WebRequest.Create("http://mud.hoikas.com/shards.xml");
fShardReq.BeginGetResponse(new AsyncCallback(IGotShardList), null);
}
public bool StartRequest(string requestUri, int timeout, ICredentials credentials)
{
if (onResponse == null) return false;
request = WebRequest.Create(requestUri);
if (credentials != null)
request.Credentials = credentials;
try
{
var rst = request.BeginGetResponse(RequestCompleted, null);
ThreadPool.RegisterWaitForSingleObject(rst.AsyncWaitHandle,
TimeoutCallback, request, timeout, true);
requestInProcess = true;
}
catch (Exception ex)
{
Logger.Error("AsynchWebRequest.StartRequest", ex);
return false;
}
return true;
}
