|
public OpenReadTaskAsync ( System address ) : System.Threading.Tasks.Task |
||
| address | System | |
| return | System.Threading.Tasks.Task |
|
async Task<int> GetBytes(string url, CancellationToken cancelToken, IProgress<DownloadBytesProgress> progressIndicator)
{
int receivedBytes = 0;
int totalBytes = -1;
WebClient client = new WebClient();
using (var stream = await client.OpenReadTaskAsync(url))
{
byte[] buffer = new byte[4096];
Int32.TryParse(client.ResponseHeaders[HttpResponseHeader.ContentLength], out totalBytes);
for (;;)
{
int len = await stream.ReadAsync(buffer, 0, buffer.Length);
if (len == 0)
{
await Task.Yield();
break;
}
receivedBytes += len;
cancelToken.ThrowIfCancellationRequested();
if (progressIndicator != null)
{
DownloadBytesProgress args = new DownloadBytesProgress(url, receivedBytes, totalBytes);
progressIndicator.Report(args);
}
}
}
return receivedBytes;
}
public static async Task<int> CreateDownloadTask(string urlToDownload, IProgress<DownloadBytesProgress> progessReporter)
{
int receivedBytes = 0;
int totalBytes = 0;
WebClient client = new WebClient();
using (var stream = await client.OpenReadTaskAsync(urlToDownload))
{
byte[] buffer = new byte[BufferSize];
totalBytes = Int32.Parse(client.ResponseHeaders[HttpResponseHeader.ContentLength]);
for (;;)
{
int bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length);
if (bytesRead == 0)
{
await Task.Yield();
break;
}
receivedBytes += bytesRead;
if (progessReporter != null)
{
DownloadBytesProgress args = new DownloadBytesProgress(urlToDownload, receivedBytes, totalBytes);
progessReporter.Report(args);
}
}
}
return receivedBytes;
}
public async Task UpdateListFromRemote()
{
var s = StorageHelper.ReadFromLocalCache(ConfigFileName, CacheDays);
if (s != null)
{
s.Dispose();
return;
}
var client = new WebClient();
try
{
s = await client.OpenReadTaskAsync(RemoteFilePath);
Debug.WriteLine("Update server list from remote");
UpdateList(s);
RefreshList();
using (s)
{
using (var reader = new StreamReader(s))
{
s.Seek(0, SeekOrigin.Begin);
StorageHelper.WriteToLocalCache(ConfigFileName, reader.ReadToEnd());
}
}
}
catch (Exception) { }
}
private Task<IEnumerable<string>> GetImageList(string artistName, CancellationToken token)
{
var replacedSpaces = artistName.Replace(" ", "_");
var siteUri = new Uri("http://htbackdrops.com/api/" + ApiKey + "/searchXML?keywords=" + replacedSpaces + "&limit=7");
var client = new WebClient();
return client
.OpenReadTaskAsync(siteUri)
.ContinueWith(readTask =>
{
if (readTask.IsFaulted)
{
Trace.WriteLine(readTask.Exception);
return new string[0];
}
var doc = new XmlDocument();
doc.Load(readTask.Result);
XmlNodeList nodelist = doc.SelectNodes("/search/images/image/id");
if (nodelist == null || nodelist.Count == 0)
{
return new string[0];
}
return nodelist
.OfType<XmlNode>()
.Select(node => node.InnerText)
.Select(imageId => "http://htbackdrops.com/api/" + ApiKey + "/download/" + imageId + "/intermediate");
}, token);
}
public Task<Stream> GetAsStreamAsync()
{
using (var webClient = new WebClient())
{
return webClient.OpenReadTaskAsync(_url);
}
}
static async Task<string> ReadStreamAsync(string url)
{
using (var client = new WebClient())
using (var reader = new StreamReader(await client.OpenReadTaskAsync(url)))
{
return await reader.ReadToEndAsync();
}
}
public void RSPEC_WebClient(string address, Uri uriAddress, byte[] data,
NameValueCollection values)
{
System.Net.WebClient webclient = new System.Net.WebClient();
// All of the following are Questionable although there may be false positives if the URI scheme is "ftp" or "file"
//webclient.Download * (...); // Any method starting with "Download"
webclient.DownloadData(address); // Noncompliant
webclient.DownloadDataAsync(uriAddress, new object()); // Noncompliant
webclient.DownloadDataTaskAsync(uriAddress); // Noncompliant
webclient.DownloadFile(address, "filename"); // Noncompliant
webclient.DownloadFileAsync(uriAddress, "filename"); // Noncompliant
webclient.DownloadFileTaskAsync(address, "filename"); // Noncompliant
webclient.DownloadString(uriAddress); // Noncompliant
webclient.DownloadStringAsync(uriAddress, new object()); // Noncompliant
webclient.DownloadStringTaskAsync(address); // Noncompliant
// Should not raise for events
webclient.DownloadDataCompleted += Webclient_DownloadDataCompleted;
webclient.DownloadFileCompleted += Webclient_DownloadFileCompleted;
webclient.DownloadProgressChanged -= Webclient_DownloadProgressChanged;
webclient.DownloadStringCompleted -= Webclient_DownloadStringCompleted;
//webclient.Open * (...); // Any method starting with "Open"
webclient.OpenRead(address);
// ^^^^^^^^^^^^^^^^^^^^^^^^^^^ {{Make sure that this http request is sent safely.}}
webclient.OpenReadAsync(uriAddress, new object()); // Noncompliant
webclient.OpenReadTaskAsync(address); // Noncompliant
webclient.OpenWrite(address); // Noncompliant
webclient.OpenWriteAsync(uriAddress, "STOR", new object()); // Noncompliant
webclient.OpenWriteTaskAsync(address, "POST"); // Noncompliant
webclient.OpenReadCompleted += Webclient_OpenReadCompleted;
webclient.OpenWriteCompleted += Webclient_OpenWriteCompleted;
//webclient.Upload * (...); // Any method starting with "Upload"
webclient.UploadData(address, data); // Noncompliant
webclient.UploadDataAsync(uriAddress, "STOR", data); // Noncompliant
webclient.UploadDataTaskAsync(address, "POST", data); // Noncompliant
webclient.UploadFile(address, "filename"); // Noncompliant
webclient.UploadFileAsync(uriAddress, "filename"); // Noncompliant
webclient.UploadFileTaskAsync(uriAddress, "POST", "filename"); // Noncompliant
webclient.UploadString(uriAddress, "data"); // Noncompliant
webclient.UploadStringAsync(uriAddress, "data"); // Noncompliant
webclient.UploadStringTaskAsync(uriAddress, "data"); // Noncompliant
webclient.UploadValues(address, values); // Noncompliant
webclient.UploadValuesAsync(uriAddress, values); // Noncompliant
webclient.UploadValuesTaskAsync(address, "POST", values);
// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
// Should not raise for events
webclient.UploadDataCompleted += Webclient_UploadDataCompleted;
webclient.UploadFileCompleted += Webclient_UploadFileCompleted;
webclient.UploadProgressChanged -= Webclient_UploadProgressChanged;
webclient.UploadStringCompleted -= Webclient_UploadStringCompleted;
webclient.UploadValuesCompleted -= Webclient_UploadValuesCompleted;
}
async public Task <Image> GetImage(string fromUrl)
{
using (System.Net.WebClient webClient = new System.Net.WebClient())
{
using (Stream stream = await webClient.OpenReadTaskAsync(fromUrl))
{
return(System.Drawing.Image.FromStream(stream));
}
}
}
/// <summary>
/// Load data from flickr
/// </summary>
/// <param name="tags"></param>
/// <returns></returns>
private static async Task<XmlNodeList> LoadDataAsync(string tags)
{
var webClient = new WebClient();
var stream = await
webClient.OpenReadTaskAsync(
new Uri($"http://api.flickr.com/services/feeds/photos_public.gne?tags={tags}"));
var xdoc = new XmlDocument();//xml doc used for xml parsing
xdoc.Load(stream);
var xNodelst = xdoc.GetElementsByTagName("entry");
return xNodelst;
}
public async Task<BitmapSource> GetPhotoAsync(string uri)
{
WebClient client = new WebClient();
Stream stream = await client.OpenReadTaskAsync(uri);
try
{
return PictureDecoder.DecodeJpeg(stream);
}
catch (COMException)
{
return null;
}
}
/// <summary>
/// Downloads an xml file from AniDB which contains all of the titles for every anime, and their IDs,
/// and saves it to disk.
/// </summary>
/// <param name="titlesFile">The destination file name.</param>
private async Task DownloadTitles(string titlesFile)
{
_logger.Debug("Downloading new AniDB titles file.");
var client = new WebClient();
await AniDbSeriesProvider.RequestLimiter.Tick();
using (var stream = await client.OpenReadTaskAsync(TitlesUrl))
using (var unzipped = new GZipStream(stream, CompressionMode.Decompress))
using (var writer = File.Open(titlesFile, FileMode.Create, FileAccess.Write))
{
await unzipped.CopyToAsync(writer).ConfigureAwait(false);
}
}
/// <summary>
/// Check if the internet is available. It connects to google.com
/// </summary>
/// <returns>If the connection to google was successful</returns>
public async static Task<bool> CheckForInternetConnection()
{
try
{
using (var client = new WebClient { Proxy = null })
using (await client.OpenReadTaskAsync("http://www.google.com"))
{
return true;
}
}
catch
{
return false;
}
}
private async Task<SyndicationFeed> DownloadFeed(string url)
{
try
{
using (WebClient client = new WebClient())
{
var stream = await client.OpenReadTaskAsync(url);
return SyndicationFeed.Load(XmlReader.Create(stream));
}
}
catch (Exception)
{
return new SyndicationFeed();
}
}
/// <summary>
/// Loads an image from an Url asynchronously
/// </summary>
/// <param name="location">The location of the image</param>
/// <returns>A BitmapImage, that can be set as a source</returns>
public static async Task<ExtendedImage> LoadImageFromUrlAsync(Uri location)
{
WebClient client = new WebClient();
ExtendedImage image = new ExtendedImage();
Stream source = await client.OpenReadTaskAsync(location);
if (location.ToString().EndsWith("gif", StringComparison.InvariantCultureIgnoreCase))
{
image.SetSource(source);
TaskCompletionSource<ExtendedImage> imageLoaded = new TaskCompletionSource<ExtendedImage>();
EventHandler loadingCompleteHandler = new EventHandler((sender, e) =>
{
imageLoaded.SetResult(image);
});
EventHandler<UnhandledExceptionEventArgs> loadingFailedHandler = new EventHandler<UnhandledExceptionEventArgs>((sender, e) =>
{
imageLoaded.SetResult(image);
#if DEBUG
if (System.Diagnostics.Debugger.IsAttached)
System.Diagnostics.Debugger.Break();
#endif
});
image.LoadingCompleted += loadingCompleteHandler;
image.LoadingFailed += loadingFailedHandler;
image = await imageLoaded.Task;
//Remove handlers, otherwise the object might be kept in the memory
image.LoadingCompleted -= loadingCompleteHandler;
image.LoadingFailed -= loadingFailedHandler;
}
else
{
BitmapImage bmp = new BitmapImage();
bmp.SetSource(source);
WriteableBitmap writeable = new WriteableBitmap(bmp);
image = ImageExtensions.ToImage(writeable);
}
source.Close();
return image;
}
private async Task<SyndicationFeed> DownloadFeed(string url)
{
try
{
using (WebClient client = new WebClient())
{
var stream = await client.OpenReadTaskAsync(url);
return SyndicationFeed.Load(XmlReader.Create(stream));
}
}
catch (Exception ex)
{
Trace.Warn("Feed Collector", "Couldn't download: " + url, ex);
return new SyndicationFeed();
}
}
public async Task<bool> HasConnectionAsync(string uri)
{
try
{
Uri theUri;
Uri.TryCreate(uri, UriKind.RelativeOrAbsolute, out theUri);
using (var client = new WebClient())
{
await client.OpenReadTaskAsync(uri);
}
}
catch
{
return false;
}
return true;
}
public async Task <TApiQueryResult> Query <TApiQueryResult>(IApiQuery <TApiQueryResult> query)
{
using (var webClient = new System.Net.WebClient())
{
webClient.QueryString = query.Parameters.Aggregate(new NameValueCollection(),
(seed, current) => {
seed.Add(current.Key, current.Value);
return(seed);
});
using (var stream = await webClient.OpenReadTaskAsync(QUERY_URL))
{
var result = _deserializer.Deserialize <TApiQueryResult>(stream);
return(result);
}
}
}
private async Task<SyndicationFeed> LoadFeed()
{
SyndicationFeed feed;
using (WebClient wc = new WebClient())
using (Stream stream = await wc.OpenReadTaskAsync(new Uri("http://businessoftech.com/podcast/feed/1")))
using (XmlReader reader = XmlReader.Create(stream, new XmlReaderSettings
{
CheckCharacters = true,
}))
{
feed = SyndicationFeed.Load(reader);
}
feed.AttributeExtensions.Add(new XmlQualifiedName("itunes", "http://www.w3.org/2000/xmlns/"), Constants.ItunesNS.NamespaceName);
return feed;
}
static async Task GetWebContentAsync()
{
WebClient myClient = new WebClient();
Stream response = await myClient.OpenReadTaskAsync("http://www.contoso.com/index.htm");
using (var reader = new StreamReader(response))
{
string line;
while((line = await reader.ReadLineAsync()) != null)
{
Console.WriteLine();
Console.WriteLine(line);
}
reader.Close();
}
response.Close();
}
public virtual async Task<int> CreateDownloadTask(
string url,
IProgress<DownloadBytesProgress> progressReporter
)
{
var receivedBytes = 0;
var client = new WebClient ();
OnStartWait ();
using (var storage = OpenStorage (url))
using (var stream = await client.OpenReadTaskAsync (url))
{
_throttle.WaitOne ();
OnStopWait ();
var buffer = new byte[BUFFER_SIZE];
var totalBytes = Int32.Parse (client.ResponseHeaders [HttpResponseHeader.ContentLength]);
while (true)
{
var bytesRead = await stream.ReadAsync (buffer, 0, buffer.Length);
if (bytesRead == 0)
{
_throttle.Release ();
break;
}
Decrypt (buffer, bytesRead);
storage.Write (buffer, 0, bytesRead);
receivedBytes += bytesRead;
if (progressReporter != null)
{
var args = new DownloadBytesProgress (url, receivedBytes, totalBytes);
progressReporter.Report (args);
}
}
}
return receivedBytes;
}
public async Task<byte[]> DownloadAsync(string url, IDictionary<string, string> headers, string method)
{
var client = new WebClient();
if (headers != null)
{
foreach (var header in headers)
client.Headers[header.Key] = header.Value;
}
var downloadStream = await client.OpenReadTaskAsync(url);
byte[] buffer = new byte[1024];
using (MemoryStream stream = new MemoryStream())
{
while (downloadStream.Read(buffer, 0, buffer.Length) > 0)
{
stream.Write(buffer, 0, buffer.Length);
}
await stream.FlushAsync();
return stream.ToArray();
}
}
private async Task<SyndicationFeed> DownloadFeed(string url)
{
if (string.IsNullOrWhiteSpace(url))
return new SyndicationFeed();
try
{
using (WebClient client = new WebClient())
{
var stream = await client.OpenReadTaskAsync(url);
var settings = new XmlReaderSettings();
settings.DtdProcessing = DtdProcessing.Parse;
return SyndicationFeed.Load(XmlReader.Create(stream, settings));
}
}
catch (Exception exc)
{
this.Logger.AddMessage("DownloadFeed", $"exception {exc.Message} while downloading Feed", url, MessageType.Error);
return new SyndicationFeed();
}
}
public static async Task <Stream> DownloadFileAsStreamAsync(string downloadUrl, CancellationToken token)
{
using (System.Net.WebClient webClient = new System.Net.WebClient())
{
int receivedBytes = 0;
Stream stream = await webClient.OpenReadTaskAsync(downloadUrl);
MemoryStream ms = new MemoryStream();
var buffer = new byte[4096];
int read = 0;
var totalBytes = Int32.Parse(webClient.ResponseHeaders[HttpResponseHeader.ContentLength]);
while ((read = await stream.ReadAsync(buffer, 0, buffer.Length, token)) > 0)
{
ms.Write(buffer, 0, read);
receivedBytes += read;
}
stream.Close();
return(ms);
}
}
private async Task<BitmapImage> Download(string imageUrl, string imageName, string imageSaveName)
{
Stream imageStream = null;
var client = new WebClient();
try
{
var imageUri = new Uri(string.Format(imageUrl, imageName));
imageStream = await client.OpenReadTaskAsync(imageUri);
}
catch (Exception ex)
{
// Let it fail if not something catastrophic
if (!(ex is WebException))
throw;
}
if (imageStream == null)
return null;
var streamResourceInfo = new StreamResourceInfo(imageStream, null);
var streamReader = new StreamReader(streamResourceInfo.Stream);
byte[] imageBytes;
using (var binaryReader = new BinaryReader(streamReader.BaseStream))
imageBytes = binaryReader.ReadBytes((int) streamReader.BaseStream.Length);
var image = new BitmapImage();
string name = imageSaveName ?? imageName;
using (var stream = _isolatedStorageFile.CreateFile(name))
{
stream.Write(imageBytes, 0, imageBytes.Length);
image.SetSource(stream);
}
return image;
}
[Category ("AndroidNotWorking")] // Fails when ran as part of the entire BCL test suite. Works when only this fixture is ran
public void DownloadMultiple ()
{
WebClient wc = new WebClient ();
var t1 = wc.OpenReadTaskAsync ("http://www.google.com/");
Assert.That (t1.Wait (15000));
Assert.IsTrue (t1.IsCompleted, "#1");
var t2 = wc.OpenReadTaskAsync ("http://www.mono-project.com/");
Assert.That (t2.Wait (15000));
Assert.IsTrue (t2.IsCompleted, "#2");
var t3 = wc.DownloadStringTaskAsync ("http://www.google.com/");
Assert.That (t3.Wait (15000));
Assert.IsTrue (t3.IsCompleted, "#3");
}
private async void DownloadImage(string uri) {
try {
var client = new WebClient();
var bi = new BitmapImage();
bi.SetSource(await client.OpenReadTaskAsync(uri));
var wb = new WriteableBitmap(bi);
using(var isoStore = IsolatedStorageFile.GetUserStoreForApplication()) {
if(!isoStore.FileExists(Number.ToString() + ".jpg")) {
using(var isoStoreFs = new IsolatedStorageFileStream(Number.ToString() + ".jpg", System.IO.FileMode.Create, isoStore)) {
wb.SaveJpeg(isoStoreFs, wb.PixelWidth, wb.PixelHeight, 0, 100);
}
} else { }
}
OnPropertyChanged("Image");
} catch(Exception) { }
}
public async Task UpdatePackageInfoAsync(PipPackageView package, CancellationToken cancel) {
string description = null;
List<string> versions = null;
using (var client = new WebClient()) {
Stream data;
try {
data = await client.OpenReadTaskAsync(new Uri(_index ?? DefaultIndex, package.Name + "/json"));
} catch (WebException) {
// No net access
return;
}
try {
using (var reader = JsonReaderWriterFactory.CreateJsonReader(data, new XmlDictionaryReaderQuotas())) {
var doc = XDocument.Load(reader);
// TODO: Get package URL
//url = (string)doc.Document
// .Elements("root")
// .Elements("info")
// .Elements("package_url")
// .FirstOrDefault();
description = (string)doc.Document
.Elements("root")
.Elements("info")
.Elements("description")
.FirstOrDefault();
versions = doc.Document
.Elements("root")
.Elements("releases")
.Elements()
.Attributes("item")
.Select(a => a.Value)
.ToList();
}
} catch (InvalidOperationException) {
}
}
cancel.ThrowIfCancellationRequested();
bool changed = false;
await _cacheLock.WaitAsync();
try {
PipPackageView inCache;
if (!_cache.TryGetValue(package.Name, out inCache)) {
inCache = _cache[package.Name] = new PipPackageView(this, package.Name, null, null);
}
if (!string.IsNullOrEmpty(description)) {
var lines = description.Split(new[] { "\r\n", "\r", "\n" }, StringSplitOptions.None);
var firstLine = string.Join(
" ",
lines.TakeWhile(s => !IsSeparatorLine(s)).Select(s => s.Trim())
);
if (firstLine.Length > 500) {
firstLine = firstLine.Substring(0, 497) + "...";
}
if (firstLine == "UNKNOWN") {
firstLine = string.Empty;
}
inCache.Description = firstLine;
package.Description = firstLine;
changed = true;
}
if (versions != null) {
var updateVersion = Pep440Version.TryParseAll(versions)
.Where(v => v.IsFinalRelease)
.OrderByDescending(v => v)
.FirstOrDefault();
inCache.UpgradeVersion = updateVersion;
package.UpgradeVersion = updateVersion;
changed = true;
}
} finally {
_cacheLock.Release();
}
if (changed) {
TriggerWriteCacheToDisk();
}
}
private void RequestRiverBedHomePageAsync(
IMethodLogger logger, int numberOfRequestsToMake)
{
var requestTimes = new ConcurrentBag<long>();
int htmlLength = 0;
try
{
var tasks =
Enumerable.Range(0, numberOfRequestsToMake)
.Select(async x =>
{
var requestStopWatch = Stopwatch.StartNew();
var webClient = new WebClient();
using (var stream = await webClient.OpenReadTaskAsync(new Uri("http://www.riverbed.com")))
using (var sr = new StreamReader(stream))
{
var html = await sr.ReadToEndAsync();
htmlLength = html.Length;
}
requestTimes.Add(requestStopWatch.ElapsedMilliseconds);
});
Task.WaitAll(tasks.ToArray());
}
catch (Exception e)
{
throw new Exception("Error getting http://www.riverbed.com: " + e.Message +
Environment.NewLine + e.StackTrace);
}
logger.WriteMethodInfo(
string.Format("Html Length [{0:n0}] chars. Request Times: Min [{1:n0}] Avg [{2:n0}] Max [{3:n0}]",
htmlLength, requestTimes.Min(), requestTimes.Average(), requestTimes.Max()));
logger.WriteMethodInfo("");
}
public async Task<PackageSpec> GetPackageInfoAsync(PackageSpec entry, CancellationToken cancel) {
string description = null;
List<string> versions = null;
lock (NotOnPyPI) {
if (NotOnPyPI.Contains(entry.Name)) {
return new PackageSpec();
}
}
using (var client = new WebClient()) {
Stream data;
try {
data = await client.OpenReadTaskAsync(new Uri(_index ?? DefaultIndex, entry.Name + "/json"));
} catch (WebException ex) {
if ((ex.Response as HttpWebResponse)?.StatusCode == HttpStatusCode.NotFound) {
lock (NotOnPyPI) {
NotOnPyPI.Add(entry.Name);
}
}
// No net access or no such package
return new PackageSpec();
}
try {
using (var reader = JsonReaderWriterFactory.CreateJsonReader(data, new XmlDictionaryReaderQuotas())) {
var doc = XDocument.Load(reader);
// TODO: Get package URL
//url = (string)doc.Document
// .Elements("root")
// .Elements("info")
// .Elements("package_url")
// .FirstOrDefault();
description = (string)doc.Document
.Elements("root")
.Elements("info")
.Elements("description")
.FirstOrDefault();
versions = doc.Document
.Elements("root")
.Elements("releases")
.Elements()
.Attributes("item")
.Select(a => a.Value)
.ToList();
}
} catch (InvalidOperationException) {
}
}
bool changed = false;
PackageSpec result;
using (await _cacheLock.LockAsync(cancel)) {
if (!_cache.TryGetValue(entry.Name, out result)) {
result = _cache[entry.Name] = new PackageSpec(entry.Name);
}
if (!string.IsNullOrEmpty(description)) {
var lines = description.Split(new[] { "\r\n", "\r", "\n" }, StringSplitOptions.None);
var firstLine = string.Join(
" ",
lines.TakeWhile(s => !IsSeparatorLine(s)).Select(s => s.Trim())
);
if (firstLine.Length > 500) {
firstLine = firstLine.Substring(0, 497) + "...";
}
if (firstLine == "UNKNOWN") {
firstLine = string.Empty;
}
result.Description = firstLine;
changed = true;
}
if (versions != null) {
var updateVersion = PackageVersion.TryParseAll(versions)
.Where(v => v.IsFinalRelease)
.OrderByDescending(v => v)
.FirstOrDefault();
result.ExactVersion = updateVersion;
changed = true;
}
}
if (changed) {
TriggerWriteCacheToDisk();
}
return result.Clone();
}
/// <summary>
/// Load image from web
/// </summary>
/// <param name="link"></param>
/// <returns></returns>
private async Task<Stream> LoadLinkAsync(string link)
{
try
{
var wc = new WebClient();
Stream s = await wc.OpenReadTaskAsync(link);
return s;
}
catch (Exception e)
{
return null;//we can't download it now
}
}
protected static async Task<XRefMap> DownloadFromWebAsync(Uri uri)
{
using (var wc = new WebClient())
using (var stream = await wc.OpenReadTaskAsync(uri))
using (var sr = new StreamReader(stream))
{
return YamlUtility.Deserialize<XRefMap>(sr);
}
}
// Saves results to a local file - with user prompt for file name
private async Task SaveResultsToFile(GPDataFile gpDataFile)
{
MessageBoxResult res = MessageBox.Show("Data file created. Would you like to download the file?", "Success", MessageBoxButton.OKCancel);
if (res == MessageBoxResult.OK)
{
WebClient webClient = new WebClient();
var stream = await webClient.OpenReadTaskAsync(gpDataFile.Uri);
SaveFileDialog dialog = new SaveFileDialog();
dialog.FileName = "Output.zip";
dialog.Filter = "Zip file (*.zip)|*.zip";
if (dialog.ShowDialog() == true)
{
try
{
using (Stream fs = (Stream)dialog.OpenFile())
{
stream.CopyTo(fs);
fs.Flush();
fs.Close();
}
}
catch (Exception ex)
{
MessageBox.Show("Error saving file :" + ex.Message);
}
}
}
}
async void settingsPage_DefaultConfigurationDebugPage_ReadFileFromUri(string uri)
{
settingsPage_DefaultConfigurationDebugPage_progressring.Visibility = Visibility.Visible;
settingsPage_DefaultConfigurationDebugPage_MainLabel.Visibility = Visibility.Collapsed;
WebClient client = new WebClient();
Stream stream = null;
try
{
stream = await client.OpenReadTaskAsync(new Uri(uri));
}
catch (Exception ex)
{
TextMessageDialog("Could not grab configuration file", "Check your internet connection and try again.\nError: " + ex.Message);
settingsPage_DefaultConfigurationDebugPage_MainLabel.Content = "Could not grab configuration file\n\n" + ex.Message;
settingsPage_DefaultConfigurationDebugPage_progressring.Visibility = Visibility.Collapsed;
return;
}
StreamReader reader = new StreamReader(stream);
settingsPage_DefaultConfigurationDebugPage_MainLabel.Content = "";
settingsPage_DefaultConfigurationDebugPage_MainLabel.Content = await reader.ReadToEndAsync();
settingsPage_DefaultConfigurationDebugPage_progressring.Visibility = Visibility.Collapsed;
settingsPage_DefaultConfigurationDebugPage_MainLabel.Visibility = Visibility.Visible;
}
protected async Task<bool> CheckConnectionAsync()
{
try
{
using (var client = new WebClient())
using (await client.OpenReadTaskAsync("http://www.google.com"))
return true;
}
catch
{
return false;
}
}
