void AccessTokenQuery_QueryResponse(object sender, WebQueryResponseEventArgs e)
{
try
{
StreamReader reader = new StreamReader(e.Response);
string strResponse = reader.ReadToEnd();
var parameters = MainUtil.GetQueryParameters(strResponse);
accessToken = parameters["oauth_token"];
accessTokenSecret = parameters["oauth_token_secret"];
userID = parameters["user_id"];
userScreenName = parameters["screen_name"];
MainUtil.SetKeyValue <string>("AccessToken", accessToken);
MainUtil.SetKeyValue <string>("AccessTokenSecret", accessTokenSecret);
MainUtil.SetKeyValue <string>("ScreenName", userScreenName);
MainUtil.SetKeyValue <string>("UserID", userID);
userLoggedIn();
Dispatcher.BeginInvoke(() =>
{
AutenticaChangeColor();
//MessageBox.Show("Você está autenticado! Agora escolha a cor e acompanhe no twitter a conta @iot4dx", "MICROSOFT @ TDC 2014", MessageBoxButton.OK);
});
}
catch (Exception ex)
{
Dispatcher.BeginInvoke(() =>
{
MessageBox.Show(ex.Message);
});
}
}
public void RefreshTokenQuery_QueryResponse(object sender, WebQueryResponseEventArgs e)
{
try
{
StreamReader reader = new StreamReader(e.Response);
string strResponse = reader.ReadToEnd();
var parameters = MainUtil.GetQueryParameters(strResponse);
accessToken = parameters["oauth_token"];
accessTokenSecret = parameters["oauth_token_secret"];
TimeSpan t = (DateTime.UtcNow - new DateTime(1970, 1, 1));
MainUtil.SetKeyValue <string>("AccessToken", accessToken);
MainUtil.SetKeyValue <string>("AccessTokenSecret", accessTokenSecret);
MainUtil.SetKeyValue <string>("Timestamp", t.TotalSeconds.ToString());
userLoggedIn();
}
catch (Exception ex)
{
Dispatcher.BeginInvoke(() =>
{
MessageBox.Show(ex.Message);
});
}
}
void AccessTokenQuery_QueryResponse(object sender, WebQueryResponseEventArgs e)
{
try
{
var parameters = TwitterHelper.GetQueryParameters((new StreamReader(e.Response)).ReadToEnd());
accessToken = parameters["oauth_token"];
accessTokenSecret = parameters["oauth_token_secret"];
userID = parameters["user_id"];
userScreenName = parameters["screen_name"];
TwitterHelper.SetKeyValue <string>("AccessToken", accessToken);
TwitterHelper.SetKeyValue <string>("AccessTokenSecret", accessTokenSecret);
TwitterHelper.SetKeyValue <string>("ScreenName", userScreenName);
Dispatcher.BeginInvoke(() =>
{
var SignInMenuItem = (Microsoft.Phone.Shell.ApplicationBarMenuItem) this.ApplicationBar.MenuItems[0];
SignInMenuItem.IsEnabled = false;
var SignOutMenuItem = (Microsoft.Phone.Shell.ApplicationBarMenuItem) this.ApplicationBar.MenuItems[1];
SignOutMenuItem.IsEnabled = true;
var tweetButton = (Microsoft.Phone.Shell.ApplicationBarIconButton) this.ApplicationBar.Buttons[0];
tweetButton.IsEnabled = true;
});
this.postMessageToTwitter();
}
catch (Exception ex)
{
Dispatcher.BeginInvoke(() =>
{
MessageBox.Show(ex.Message);
});
}
}
void AccessTokenQuery_QueryResponse(object sender, WebQueryResponseEventArgs e)
{
try
{
StreamReader reader = new StreamReader(e.Response);
string strResponse = reader.ReadToEnd();
var parameters = MainUtil.GetQueryParameters(strResponse);
accessToken = parameters["oauth_token"];
accessTokenSecret = parameters["oauth_token_secret"];
userID = parameters["user_id"];
userScreenName = parameters["screen_name"];
MainUtil.SetKeyValue <string>("AccessToken", accessToken);
MainUtil.SetKeyValue <string>("AccessTokenSecret", accessTokenSecret);
MainUtil.SetKeyValue <string>("ScreenName", userScreenName);
Dispatcher.BeginInvoke(() =>
{
MessageBox.Show("Access Granted for " + userScreenName);
App.twaccesstokenkey = accessToken;
App.twaccesstokensecret = accessTokenSecret;
App.writeBackToken();
NavigationService.GoBack();
});
}
catch (Exception ex)
{
Dispatcher.BeginInvoke(() =>
{
MessageBox.Show("2)" + ex.ToString());
});
}
}
void requestTokenQuery_QueryResponse(object sender, WebQueryResponseEventArgs e)
{
Deployment.Current.Dispatcher.BeginInvoke(() => {
try {
StreamReader reader = new StreamReader(e.Response);
string strResponse = reader.ReadToEnd();
var parameters = KeyValuePairUtils.GetQueryParameters(strResponse);
TwitterClient.OAuthTokenKey = parameters["oauth_token"];
TwitterClient.TokenSecret = parameters["oauth_token_secret"];
var authorizeUrl = AppSettings.AuthorizeUri + "?oauth_token=" + TwitterClient.OAuthTokenKey;
Deployment.Current.Dispatcher.BeginInvoke(() => {
_browser.Source = new Uri(authorizeUrl, UriKind.RelativeOrAbsolute);
CurrentUrl = authorizeUrl;
});
} catch (Exception ex) {
fail();
}
});
}
private void requestTokenQuery_QueryResponse(object sender, WebQueryResponseEventArgs e)
{
try
{
StreamReader reader = new StreamReader(e.Response);
string strResponse = reader.ReadToEnd();
var parameters = GetQueryParameters(strResponse);
oAuthTokenKey = parameters["oauth_token"];
tokenSecret = parameters["oauth_token_secret"];
var authorizeUrl = Social.TwitterSettings.AuthorizeUri + "?oauth_token=" + oAuthTokenKey;
Dispatcher.BeginInvoke(() =>
{
this.BrowserControl.Navigate(new Uri(authorizeUrl, UriKind.RelativeOrAbsolute));
});
}
catch (Exception ex)
{
Debug.WriteLine("SocialPages :: requestTokenQuery_QueryResponse : TwitterAuth , Exception:" + ex.StackTrace);
}
}
void requestTokenQuery_QueryResponse(object sender, WebQueryResponseEventArgs e)
{
try
{
var parameters = TwitterHelper.GetQueryParameters((new StreamReader(e.Response)).ReadToEnd());
OAuthTokenKey = parameters["oauth_token"];
tokenSecret = parameters["oauth_token_secret"];
var authorizeUrl = AppSettings.TwitterAuthorizeUri + "?oauth_token=" + OAuthTokenKey;
Dispatcher.BeginInvoke(() =>
{
this.wbTwitter.Navigate(new Uri(authorizeUrl));
});
}
catch (Exception ex)
{
Dispatcher.BeginInvoke(() =>
{
MessageBox.Show(ex.Message);
});
}
}
void AccessTokenQuery_QueryResponse(object sender, WebQueryResponseEventArgs e)
{
try {
Deployment.Current.Dispatcher.BeginInvoke(() => {
StreamReader reader = new StreamReader(e.Response);
string strResponse = reader.ReadToEnd();
var parameters = KeyValuePairUtils.GetQueryParameters(strResponse);
TwitterClient.AccessToken = parameters["oauth_token"];
TwitterClient.AccessTokenSecret = parameters["oauth_token_secret"];
TwitterClient.UserID = parameters["user_id"];
TwitterClient.UserScreenName = parameters["screen_name"];
KeyValuePairUtils.SetKeyValue <string>(TwitterClient.KeyAcessToken, TwitterClient.AccessToken);
KeyValuePairUtils.SetKeyValue <string>(TwitterClient.KeyAcessTokenSecret, TwitterClient.AccessTokenSecret);
KeyValuePairUtils.SetKeyValue <string>(TwitterClient.KeyUserName, TwitterClient.UserScreenName);
KeyValuePairUtils.SetKeyValue <string>(TwitterClient.KeyUserID, TwitterClient.UserID);
success(parameters["oauth_token"], parameters["oauth_token_secret"]);
});
} catch (Exception ex) {
fail();
}
}
void AccessTokenQuery_QueryResponse(object sender, WebQueryResponseEventArgs e)
{
try
{
StreamReader reader = new StreamReader(e.Response);
string strResponse = reader.ReadToEnd();
var parameters = GetQueryParameters(strResponse);
App.WriteToIsoStorageSettings(HikeConstants.AppSettings.TWITTER_TOKEN, parameters["oauth_token"]);
App.WriteToIsoStorageSettings(HikeConstants.AppSettings.TWITTER_TOKEN_SECRET, parameters["oauth_token_secret"]);
App.WriteToIsoStorageSettings(HikeConstants.TW_LOGGED_IN, true);
Dispatcher.BeginInvoke(() =>
{
PhoneApplicationService.Current.State["socialState"] = FreeSMS.SocialState.TW_LOGIN;
if (NavigationService.CanGoBack)
{
NavigationService.GoBack();
}
});
}
catch (Exception ex)
{
Debug.WriteLine("SocialPages::AccessTokenQuery_QueryResponse, Exception:" + ex.StackTrace);
}
}
void requestTokenQuery_QueryResponse(object sender, WebQueryResponseEventArgs e)
{
try
{
StreamReader reader = new StreamReader(e.Response);
string strResponse = reader.ReadToEnd();
var parameters = MainUtil.GetQueryParameters(strResponse);
OAuthTokenKey = parameters["oauth_token"];
tokenSecret = parameters["oauth_token_secret"];
var authorizeUrl = TwitterSettings.AuthorizeUri + "?oauth_token=" + OAuthTokenKey;
Dispatcher.BeginInvoke(() =>
{
this.loginBrowserControl.Navigate(new Uri(authorizeUrl, UriKind.RelativeOrAbsolute));
});
}
catch (Exception ex)
{
Dispatcher.BeginInvoke(() =>
{
MessageBox.Show(ex.Message);
});
}
}
/// <summary>
/// Handles the OpenReadCompleted event of the client control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.Net.OpenReadCompletedEventArgs"/> instance containing the event data.</param>
protected virtual void client_OpenReadCompleted(object sender, OpenReadCompletedEventArgs e)
{
// TODO: AsyncCompletedEventArgs?
#if !SILVERLIGHT
if (e.Error != null)
{
var args = new WebQueryResponseEventArgs(e.Error.Message, e.Error as WebException);
OnQueryResponse(args);
}
#endif
try
{
using (var stream = e.Result)
{
if (stream != null)
{
using (var reader = new StreamReader(stream))
{
var result = reader.ReadToEnd();
WebResponse = ((IWebQueryClient)sender).Response;
if (e.UserState != null)
{
// no expiration specified
if (e.UserState is Pair<IClientCache, string>)
{
var state = (e.UserState as Pair<IClientCache, string>);
state.First.Insert(state.Second, result);
}
// absolute expiration specified
if (e.UserState is Pair<IClientCache, Pair<string, DateTime>>)
{
var state = e.UserState as Pair<IClientCache, Pair<string, DateTime>>;
state.First.Insert(state.Second.First, result, state.Second.Second);
}
// sliding expiration specified
if (e.UserState is Pair<IClientCache, Pair<string, TimeSpan>>)
{
var state = e.UserState as Pair<IClientCache, Pair<string, TimeSpan>>;
state.First.Insert(state.Second.First, result, state.Second.Second);
}
}
// only send query when caching is complete
var args = new WebQueryResponseEventArgs(result);
OnQueryResponse(args);
}
}
else
{
Exception ex = e.UserState as Exception;
if (ex != null)
{
WebException webEx = ex as WebException;
string msg;
if (webEx != null)
{
HandleWebException(webEx);
}
else
{
webEx = new WebException("Some kind of a web exception", ex);
HandleWebException(webEx);
}
}
}
}
}
catch (WebException ex)
{
var message = HandleWebException(ex);
var args = new WebQueryResponseEventArgs(message, ex);
OnQueryResponse(args);
}
}
// expects real cache key, not prefix
private void ExecuteGetAsyncAndCacheWithExpiry(IClientCache cache, string key, string url,
TimeSpan slidingExpiration, IWebQueryClient client)
{
var fetch = cache.Get<string>(key);
if (fetch != null)
{
var args = new WebQueryResponseEventArgs(fetch);
OnQueryResponse(args);
}
else
{
var state = new Pair<IClientCache, Pair<string, TimeSpan>>
{
First = cache,
Second = new Pair<string, TimeSpan> {First = key, Second = slidingExpiration}
};
var args = new WebQueryRequestEventArgs(url);
OnQueryRequest(args);
client.OpenReadCompleted += client_OpenReadCompleted;
client.OpenReadAsync(new Uri(url), state);
}
}
protected virtual void PostAsyncResponseCallback(IAsyncResult asyncResult)
{
var state = asyncResult.AsyncState as Pair<WebRequest, Triplet<IClientCache, object, string>>;
if (state == null)
{
throw new ArgumentNullException("asyncResult", "The asynchronous post failed to return its state");
}
var request = state.First;
if (request == null)
{
throw new ArgumentNullException("asyncResult", "The asynchronous post failed to return a request");
}
try
{
// Avoid disposing until no longer needed to build results
var response = request.EndGetResponse(asyncResult);
WebResponse = response;
using (var reader = new StreamReader(response.GetResponseStream()))
{
var result = reader.ReadToEnd();
if (state.Second != null)
{
var cache = state.Second.First;
var expiry = state.Second.Second;
var url = request.RequestUri.ToString();
var prefix = state.Second.Third;
var key = CreateCacheKey(prefix, url);
if (expiry is DateTime)
{
// absolute
cache.Insert(key, result, (DateTime) expiry);
}
if (expiry is TimeSpan)
{
// sliding
cache.Insert(key, result, (TimeSpan) expiry);
}
}
var args = new WebQueryResponseEventArgs(result);
OnQueryResponse(args);
}
}
catch (WebException ex)
{
HandleWebException(ex);
}
}
protected virtual void PostAsyncRequestCallback(IAsyncResult asyncResult)
{
WebRequest request;
byte[] content;
Triplet<IClientCache, object, string> store;
var state = asyncResult.AsyncState as Pair<WebRequest, byte[]>;
if (state == null)
{
// no expiration specified
if (asyncResult is Pair<WebRequest, Triplet<byte[], IClientCache, string>>)
{
var cacheScheme = (Pair<WebRequest, Triplet<byte[], IClientCache, string>>) asyncResult;
var cache = cacheScheme.Second.Second;
var url = cacheScheme.First.RequestUri.ToString();
var prefix = cacheScheme.Second.Third;
var key = CreateCacheKey(prefix, url);
var fetch = cache.Get<string>(key);
if (fetch != null)
{
var args = new WebQueryResponseEventArgs(fetch);
OnQueryResponse(args);
return;
}
request = cacheScheme.First;
content = cacheScheme.Second.First;
store = new Triplet<IClientCache, object, string> {First = cache, Second = null, Third = prefix};
}
else
// absolute expiration specified
if (asyncResult is Pair<WebRequest, Pair<byte[], Triplet<IClientCache, DateTime, string>>>)
{
var cacheScheme =
(Pair<WebRequest, Pair<byte[], Triplet<IClientCache, DateTime, string>>>) asyncResult;
var url = cacheScheme.First.RequestUri.ToString();
var cache = cacheScheme.Second.Second.First;
var expiry = cacheScheme.Second.Second.Second;
var prefix = cacheScheme.Second.Second.Third;
var key = CreateCacheKey(prefix, url);
var fetch = cache.Get<string>(key);
if (fetch != null)
{
var args = new WebQueryResponseEventArgs(fetch);
OnQueryResponse(args);
return;
}
request = cacheScheme.First;
content = cacheScheme.Second.First;
store = new Triplet<IClientCache, object, string>
{First = cache, Second = expiry, Third = prefix};
}
else
// sliding expiration specified
if (asyncResult is Pair<WebRequest, Pair<byte[], Triplet<IClientCache, TimeSpan, string>>>)
{
var cacheScheme =
(Pair<WebRequest, Pair<byte[], Triplet<IClientCache, TimeSpan, string>>>) asyncResult;
var url = cacheScheme.First.RequestUri.ToString();
var cache = cacheScheme.Second.Second.First;
var expiry = cacheScheme.Second.Second.Second;
var prefix = cacheScheme.Second.Second.Third;
var key = CreateCacheKey(prefix, url);
var fetch = cache.Get<string>(key);
if (fetch != null)
{
var args = new WebQueryResponseEventArgs(fetch);
OnQueryResponse(args);
return;
}
request = cacheScheme.First;
content = cacheScheme.Second.First;
store = new Triplet<IClientCache, object, string>
{First = cache, Second = expiry, Third = prefix};
}
else
{
// unrecognized state signature
throw new ArgumentNullException("asyncResult",
"The asynchronous post failed to return its state");
}
}
else
{
request = state.First;
content = state.Second;
store = null;
}
// no cached response
using (var stream = request.EndGetRequestStream(asyncResult))
{
if (content != null)
{
stream.Write(content, 0, content.Length);
}
stream.Close();
request.BeginGetResponse(PostAsyncResponseCallback,
new Pair<WebRequest, Triplet<IClientCache, object, string>>
{First = request, Second = store});
}
}
protected string HandleWebException(WebException ex)
{
if (ex.Response is HttpWebResponse && ex.Response != null)
{
WebResponse = ex.Response;
using (var reader = new StreamReader(WebResponse.GetResponseStream()))
{
var result = reader.ReadToEnd();
var args = new WebQueryResponseEventArgs(result, ex);
OnQueryResponse(args);
return result;
}
}
else
{
var args = new WebQueryResponseEventArgs(null, ex);
OnQueryResponse(args);
}
return string.Empty;
}
protected virtual string ExecutePostOrPut(PostOrPut method, string url, IEnumerable<HttpPostParameter> parameters)
{
WebResponse = null;
byte[] bytes;
var request = BuildMultiPartFormRequest(method, url, parameters, out bytes);
using (var requestStream = request.GetRequestStream())
{
requestStream.Write(bytes, 0, bytes.Length);
requestStream.Flush();
requestStream.Close();
// Avoid disposing until no longer needed to build results
var response = request.GetResponse();
WebResponse = response;
using (var reader = new StreamReader(response.GetResponseStream()))
{
var result = reader.ReadToEnd();
var responseArgs = new WebQueryResponseEventArgs(result);
OnQueryResponse(responseArgs);
WebResponse = response;
return result;
}
}
}
protected virtual string ExecutePostOrPut(PostOrPut method, string url, out WebException exception)
{
WebResponse = null;
exception = null;
byte[] content;
var request = BuildPostOrPutWebRequest(method, url, out content);
var requestArgs = new WebQueryRequestEventArgs(url);
OnQueryRequest(requestArgs);
try
{
using (var stream = request.GetRequestStream())
{
stream.Write(content, 0, content.Length);
stream.Close();
// Avoid disposing until no longer needed to build results
var response = request.GetResponse();
WebResponse = response;
using (var reader = new StreamReader(response.GetResponseStream()))
{
var result = reader.ReadToEnd();
var responseArgs = new WebQueryResponseEventArgs(result);
OnQueryResponse(responseArgs);
return result;
}
}
}
catch (WebException ex)
{
exception = ex;
return HandleWebException(ex);
}
}
protected virtual string ExecuteGet(string url, out WebException exception)
{
WebResponse = null;
var client = CreateWebQueryClient();
var requestArgs = new WebQueryRequestEventArgs(url);
OnQueryRequest(requestArgs);
try
{
using (var stream = client.OpenRead(url))
{
using (var reader = new StreamReader(stream))
{
var result = reader.ReadToEnd();
var responseArgs = new WebQueryResponseEventArgs(result);
OnQueryResponse(responseArgs);
return result;
}
}
}
catch (WebException ex)
{
client.Exception = client.Exception ?? ex;
return HandleWebException(ex);
}
finally
{
exception = client.Exception;
WebResponse = client.Response;
}
}
public virtual void ExecuteStreamGet(string url, TimeSpan duration, int resultCount)
{
WebResponse = null;
var client = CreateWebQueryClient();
var requestArgs = new WebQueryRequestEventArgs(url);
OnQueryRequest(requestArgs);
Stream stream = null;
try
{
using (stream = client.OpenRead(url))
{
// [DC]: cannot refactor this block to common method; will cause wc/hwr to hang
var count = 0;
var results = new List<string>();
var start = DateTime.UtcNow;
using (var reader = new StreamReader(stream))
{
var line = "";
while ((line = reader.ReadLine()).Length > 0)
{
if (line.Equals(Environment.NewLine))
{
// Keep-Alive
continue;
}
if (line.Equals("<html>"))
{
// We're looking at a 401 or similar; construct error result?
return;
}
results.Add(line);
count++;
if (count < resultCount)
{
// Result buffer
continue;
}
var sb = new StringBuilder();
foreach (var result in results)
{
sb.AppendLine(result);
}
var responseArgs = new WebQueryResponseEventArgs(sb.ToString());
OnQueryResponse(responseArgs);
count = 0;
var now = DateTime.UtcNow;
if (duration == TimeSpan.Zero || now.Subtract(start) < duration)
{
continue;
}
// Time elapsed
client.CancelAsync();
return;
}
// Stream dried up
}
client.CancelAsync();
}
}
catch (WebException ex)
{
client.Exception = client.Exception ?? ex;
}
finally
{
if (stream != null)
{
stream.Close();
stream.Dispose();
}
WebResponse = client.Response;
}
}
/// <summary>
/// Raises the <see cref="QueryResponse"/> event.
/// </summary>
/// <param name="args">The <see cref="TweetSharp.Core.Web.WebQueryResponseEventArgs"/> instance containing the event data.</param>
public virtual void OnQueryResponse(WebQueryResponseEventArgs args)
{
if (QueryResponse != null)
{
QueryResponse(this, args);
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary> Executes the request return action. </summary>
///
/// <remarks> Olivier Gagnon, 2009-11-18. </remarks>
///
/// <param name="sender"> Source of the event. </param>
/// <param name="e"> Event information to send to registered event handlers. </param>
///////////////////////////////////////////////////////////////////////////////////////////////////
private static void OnRequestReturn(TweetWin tw, WebQueryResponseEventArgs e)
{
Console.WriteLine(e.Response);
TwitterRateLimitStatus crate = e.Response.AsRateLimitStatus();
string chitsleft = String.Format("{0}/{1} hits remaining. Resets at: {2}",
crate.RemainingHits, crate.HourlyLimit,
crate.ResetTime.TimeOfDay);
if (tw.InvokeRequired)
{
tw.Invoke((Action) (() => { tw.StatusText.Text = chitsleft; }));
}
else
tw.StatusText.Text = chitsleft;
}
protected override string ExecuteGet(string url, out WebException exception)
{
WebResponse = null;
exception = null;
var client = CreateWebQueryClient();
if (HasAuth)
{
client.WebCredentials = new WebCredentials(_username, _password);
}
var requestArgs = new WebQueryRequestEventArgs(url);
OnQueryRequest(requestArgs);
// todo too much code duplication with base class
try
{
using (var stream = client.OpenRead(url))
{
exception = client.Exception;
using (var reader = new StreamReader(stream))
{
var result = reader.ReadToEnd();
var responseArgs = new WebQueryResponseEventArgs(result);
OnQueryResponse(responseArgs);
return result;
}
}
}
catch (WebException ex)
{
exception = client.Exception ?? ex;
return HandleWebException(ex);
}
finally
{
if (WebResponse == null || client.Response != null)
{
WebResponse = client.Response;
}
if ( WebResponse == null && client.Request != null )
{
WebResponse = client.GetWebResponseShim(client.Request);
}
}
}
public virtual void ExecuteStreamPost(PostOrPut method, string url, TimeSpan duration, int resultCount)
{
WebResponse = null;
byte[] content;
var request = BuildPostOrPutWebRequest(method, url, out content);
var requestArgs = new WebQueryRequestEventArgs(url);
OnQueryRequest(requestArgs);
Stream stream = null;
try
{
using (stream = request.GetRequestStream())
{
stream.Write(content, 0, content.Length);
stream.Close();
var response = request.GetResponse();
WebResponse = response;
using (var responseStream = response.GetResponseStream())
{
// [DC]: cannot refactor this block to common method; will cause hwr to hang
var count = 0;
var results = new List<string>();
var start = DateTime.UtcNow;
using (var reader = new StreamReader(responseStream))
{
var line = "";
while ((line = reader.ReadLine()).Length > 0)
{
if (line.Equals(Environment.NewLine))
{
// Keep-Alive
continue;
}
if (line.Equals("<html>"))
{
// We're looking at a 401 or similar; construct error result?
return;
}
results.Add(line);
count++;
if (count < resultCount)
{
// Result buffer
continue;
}
var sb = new StringBuilder();
foreach (var result in results)
{
sb.AppendLine(result);
}
var responseArgs = new WebQueryResponseEventArgs(sb.ToString());
OnQueryResponse(responseArgs);
count = 0;
var now = DateTime.UtcNow;
if (now.Subtract(start) >= duration)
{
// Time elapsed
request.Abort();
return;
}
}
// Stream dried up
}
}
}
}
catch (WebException)
{
//
}
finally
{
if (stream != null)
{
stream.Close();
stream.Dispose();
}
}
}
protected virtual void client_OpenReadStreamCompleted(object sender, OpenReadCompletedEventArgs e)
{
#if !SILVERLIGHT
if (e.Error != null)
{
var args = new WebQueryResponseEventArgs(e.Error.Message, e.Error as WebException);
OnQueryResponse(args);
}
#endif
var stream = e.Result;
if (stream == null)
{
return;
}
var client = ((IWebQueryClient) sender);
var state = (Pair<TimeSpan, int>) e.UserState;
var duration = state.First;
var resultCount = state.Second;
try
{
using (stream = e.Result)
{
if (stream != null)
{
var count = 0;
var results = new List<string>();
var start = DateTime.UtcNow;
using (var reader = new StreamReader(stream))
{
var line = "";
while ((line = reader.ReadLine()).Length > 0)
{
if (line.Equals(Environment.NewLine))
{
// Keep-Alive
continue;
}
if (line.Equals("<html>"))
{
// We're looking at a 401 or similar; construct error result?
return;
}
results.Add(line);
count++;
if (count < resultCount)
{
// Result buffer
continue;
}
var sb = new StringBuilder();
foreach (var result in results)
{
sb.AppendLine(result);
}
var responseArgs = new WebQueryResponseEventArgs(sb.ToString());
OnQueryResponse(responseArgs);
count = 0;
var now = DateTime.UtcNow;
if (now.Subtract(start) >= duration)
{
// Time elapsed
client.CancelAsync();
return;
}
}
// Stream dried up
}
client.CancelAsync();
}
}
}
catch (WebException)
{
//
}
finally
{
if (stream != null)
{
stream.Close();
stream.Dispose();
}
WebResponse = client.Response;
}
}
