public DownloadDataTaskAsync ( System address ) : System.Threading.Tasks.Task |
||
address | System | |
return | System.Threading.Tasks.Task |
public static async Task BeginDownloadMinecraft(this MainWindow window) { window.LoadingBox.Visibility = Visibility.Visible; window.LoadingText.Content = "Updating Minecraft..."; window.LoadingProgress.IsIndeterminate = true; if (!Directory.Exists(Globals.LauncherDataPath + @"\Minecraft")) Directory.CreateDirectory(Globals.LauncherDataPath + @"\Minecraft"); if (!Directory.Exists(Globals.LauncherDataPath + @"\Minecraft\bin")) Directory.CreateDirectory(Globals.LauncherDataPath + @"\Minecraft\bin"); if (!Directory.Exists(Globals.LauncherDataPath + @"\Minecraft\bin\natives")) Directory.CreateDirectory(Globals.LauncherDataPath + @"\Minecraft\bin\natives"); WebClient c = new WebClient(); try { if ((long)Settings.Default["CachedLWJGLTimestamp"] == null || LauncherInformation.Current.LWJGLTimestamp > (long)Settings.Default["CachedLWJGLTimestamp"]) { window.LoadingText.Content = "Downloading updated LWJGL..."; byte[] d = await c.DownloadDataTaskAsync(LauncherInformation.Current.LWJGLLocation); ZipFile f = ZipFile.Read(new MemoryStream(d)); f.ExtractAll(Globals.LauncherDataPath + @"\Minecraft\bin", ExtractExistingFileAction.OverwriteSilently); Settings.Default["CachedLWJGLTimestamp"] = LauncherInformation.Current.LWJGLTimestamp; Settings.Default.Save(); } if((long)Settings.Default["CachedMinecraftTimestamp"] == null || LauncherInformation.Current.MinecraftTimestamp > (long)Settings.Default["CachedMinecraftTimestamp"]) { MessageBoxResult r = MessageBox.Show("Do you want to update Minecraft? (Latest version: " + LauncherInformation.Current.MinecraftVersion + ")", "MCLauncher", MessageBoxButton.YesNo, MessageBoxImage.Question); if (r == MessageBoxResult.Yes) { window.LoadingText.Content = "Downloading Minecraft " + LauncherInformation.Current.MinecraftVersion + "..."; byte[] mc = await c.DownloadDataTaskAsync(LauncherInformation.Current.MinecraftLocation); File.WriteAllBytes(Globals.LauncherDataPath + @"\Minecraft\bin\minecraft.jar", mc); Settings.Default["CachedMinecraftTimestamp"] = LauncherInformation.Current.MinecraftTimestamp; Settings.Default.Save(); } } } catch (WebException ex) { MessageBox.Show("Failed to update Minecraft. Is your internet down? Exception information: " + ex.ToString(), "An error has occured.", MessageBoxButton.OK, MessageBoxImage.Error); } finally { c.Dispose(); } }
private async Task <MemoryStream> InvokeCreation(Models.GenerationRequest data) { MemoryStream ms; var path = data.Template.Url; var client = new System.Net.WebClient(); var src = await client.DownloadDataTaskAsync(path); Scryber.Components.Document doc = null; using (ms = new MemoryStream(src)) { doc = Scryber.Components.Document.ParseDocument(ms, path, ParseSourceType.RemoteFile); } if (data.Params != null) { foreach (var p in data.Params) { doc.Params[p.Key] = p.Value; } } ms = new MemoryStream(); doc.SaveAsPDF(ms, true); return(ms); }
private static async void RunFetchLoopAsync(IActorRef publisher, string url, string source) { await Task.Yield(); try { var c = new WebClient(); while (true) { var data = await c.DownloadDataTaskAsync(new Uri(url)); var str = Encoding.UTF8.GetString(data); dynamic res = JsonConvert.DeserializeObject(str); // Console.WriteLine("Downloaded {0}",url); foreach (var bus in res) { string id = bus.ID; double lat = bus.Latitude; double lon = bus.Longitude; publisher.Tell(new Presenter.Position(lon, lat, id, source)); } //how long should we wait before polling again? await Task.Delay(TimeSpan.FromSeconds(1)); } } catch { Console.WriteLine("Missing Route {0}", url); } }
[Category("AndroidNotWorking")] // Attempts to access the test dll which won't work on Android public void DownloadData () { WebClient wc; bool progress_changed = false; bool completed = false; bool progress_changed_error = false; bool completed_error = false; int thread_id = Thread.CurrentThread.ManagedThreadId; wc = new WebClient (); wc.DownloadProgressChanged += delegate { progress_changed = true; if (Thread.CurrentThread.ManagedThreadId != thread_id) progress_changed_error = true; }; wc.DownloadDataCompleted += delegate { completed = true; if (Thread.CurrentThread.ManagedThreadId != thread_id) completed_error = true; }; MessagePumpSyncContext.Run (async () => { var url = Assembly.GetExecutingAssembly ().CodeBase; await wc.DownloadDataTaskAsync (url); Assert.AreEqual (Thread.CurrentThread.ManagedThreadId, thread_id); }, () => progress_changed && completed, 10000); Assert.IsTrue (progress_changed, "#1"); Assert.IsFalse (progress_changed_error, "#2"); Assert.IsTrue (completed, "#3"); Assert.IsFalse (completed_error, "#4"); }
private static IObservable<byte[]> CreateObservableTimePoller() { return Observable.Create<byte[]>(observer => { var scheduler = Scheduler.Default; return scheduler.ScheduleAsync(async (schedulerController, cancelletionToken) => { while (!cancelletionToken.IsCancellationRequested) { var client = new WebClient(); client.Headers.Add("user-agent", @"Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.2; Trident/6.0)"); try { var result = await client.DownloadDataTaskAsync("http://www.timeapi.org/utc/now"); observer.OnNext(result); } catch (Exception ex) { Console.WriteLine(ex); observer.OnError(ex); } await schedulerController.Sleep(TimeSpan.FromMilliseconds(500), cancelletionToken); } }); }); }
private async Task<byte[]> downloadImage(string path) { using (var wb = new WebClient()) { return await wb.DownloadDataTaskAsync(path); } }
public static async Task<string> DownloadPageAsync(string path) { using (var webClient = new WebClient()) { return Encoding.UTF8.GetString(await webClient.DownloadDataTaskAsync(path)); } }
private static async Task<byte[]> DownloadProfilePhoto(string profileUrlString, byte[] emptyPhotoBytes) { var webClient = new WebClient(); webClient.UseDefaultCredentials = true; byte[] blobBytes = new byte[emptyPhotoBytes.Length]; try { blobBytes = await webClient.DownloadDataTaskAsync(profileUrlString); } catch (WebException webException) { if (webException.Status == WebExceptionStatus.ProtocolError) { if (((HttpWebResponse)webException.Response).StatusCode == HttpStatusCode.NotFound) { emptyPhotoBytes.CopyTo(blobBytes, 0); } } else if (webException.Status == WebExceptionStatus.NameResolutionFailure) { emptyPhotoBytes.CopyTo(blobBytes, 0); } else { throw webException; } } return blobBytes; }
public async Task DownloadAndRunAsync() { if (string.IsNullOrWhiteSpace(SupportUrl)) { throw Log.ErrorAndCreateException<InvalidOperationException>("Please initialize the service by setting the SupportUrl property"); } Log.Info("Downloading support app from '{0}'", SupportUrl); var webClient = new WebClient(); webClient.DownloadProgressChanged += OnWebClientOnDownloadProgressChanged; webClient.DownloadDataCompleted += OnWebClientOnDownloadDataCompleted; var data = await webClient.DownloadDataTaskAsync(SupportUrl); Log.Info("Support app is downloaded, storing file in temporary folder"); var tempDirectory = Path.Combine(Path.GetTempPath(), "Orc_AutomaticSupport", DateTime.Now.ToString("yyyyMMddHHmmss")); if (!Directory.Exists(tempDirectory)) { Directory.CreateDirectory(tempDirectory); } var tempFile = Path.Combine(tempDirectory, "SupportApp.exe"); File.WriteAllBytes(tempFile, data); Log.Info("Running support app"); _processService.StartProcess(tempFile, CommandLineParameters, exitCode => { _dispatcherService.BeginInvoke(() => SupportAppClosed.SafeInvoke(this)); }); }
public async Task<long> GetPageSize(CancellationToken cToken) { WebClient wc = new WebClient(); Stopwatch sw = Stopwatch.StartNew(); byte[] apressData = await wc.DownloadDataTaskAsync(TargetUrl); Debug.WriteLine("Elapsed ms: {0}", sw.ElapsedMilliseconds); return apressData.LongLength; //List<long> results = new List<long>(); //for (int i = 0; i < 10; i++) //{ // if (!cToken.IsCancellationRequested) // { // Debug.WriteLine("Making Request: {0}", i); // byte[] apressData = await wc.DownloadDataTaskAsync(TargetUrl); // results.Add(apressData.LongLength); // } // else // { // Debug.WriteLine("Cancelled"); // return 0; // } //} ////byte[] apressData = await wc.DownloadDataTaskAsync(TargetUrl); //Debug.WriteLine("Elapsed ms: {0}", sw.ElapsedMilliseconds); ////return apressData.LongLength; //return (long)results.Average(); }
public void DownloadDataTaskAsyncWhenCancellationTokenAndUriIsNullTest() { var webClient = new WebClient(); var exception = Assert.Throws<ArgumentNullException>(() => webClient.DownloadDataTaskAsync(null, new CancellationToken())); Assert.AreEqual("uri", exception.ParamName); }
private async void DownloadImageAsync() { try { var webClient = new WebClient(); var data = await webClient.DownloadDataTaskAsync("http://www.dot42.com/dot42/img/logo.png").ConfigureAwait(this); var textView = FindViewById<TextView>(R.Ids.MyText); var bitmap = BitmapFactory.DecodeByteArray(data, 0, data.Length); if (bitmap == null) { textView.SetText("BitmapFactory cannot convert bytes into Bitmap"); } else { textView.SetText("Ready:"); var imageView = FindViewById<ImageView>(R.Ids.MyImage); imageView.SetImageBitmap(bitmap); } } catch (Exception ex) { var textView = FindViewById<TextView>(R.Ids.MyText); textView.SetText("Exception: " + ex.Message); } }
private async Task <Stream> GetStream(Uri imageUri) { // BitmapImage can download on its own from URIs, but in order // to support downloading on a worker thread, we need to download the image // data and put into a memorystream. Then have the BitmapImage decode the // image from the memorystream. byte[] imageData = null; MemoryStream ms = null; using (var wc = new System.Net.WebClient()) { try { imageData = await wc.DownloadDataTaskAsync(imageUri); ms = new MemoryStream(imageData, writable: false); } catch (WebException webex) { if (BadNetworkErrors.Any(c => webex.Status == c)) { ErrorFloodGate.ReportBadNetworkError(); BitmapStatus = IconBitmapStatus.DefaultIconDueToWebExceptionBadNetwork; } else { BitmapStatus = IconBitmapStatus.DefaultIconDueToWebExceptionOther; } } } return(ms); }
public Task<byte[]> GetAsByteArrayAsync() { using (var webClient = new WebClient()) { return webClient.DownloadDataTaskAsync(_url); } }
public async Task ResetAsync(string CalculatorId) { using (var client = new WebClient()) { await client.DownloadDataTaskAsync(new Uri(this.url + "reset?id=" + CalculatorId)); } }
private async Task<Dictionary<string, SongInfo[]>> GetSongIdMap(bool remote) { try { if (remote) { using (var client = new WebClient()) { var data = await client.DownloadDataTaskAsync(new Uri($"https://apiv2.deresute.info/data/live")); using (var stream = new MemoryStream(data)) { Directory.CreateDirectory("data/patterns"); File.WriteAllBytes($"data/patterns/index", data); return ParseSongIdMap(stream); } } } else { using (var fs = File.OpenRead($"data/patterns/index")) { return ParseSongIdMap(fs); } } } catch { return null; } }
public static void Main(string[] args) { var urls = Console.In.ReadToEnd().Split(new string[]{Environment.NewLine}, StringSplitOptions.RemoveEmptyEntries); var dir = args[0]; Func<string, Task> download = async (url) => { var wc = new WebClient(); var uri = new Uri(url); var fileName = Path.Combine(dir, Path.GetFileName(url)); try { byte[] buf = await wc.DownloadDataTaskAsync(uri); using (var fs = new FileStream(fileName, FileMode.Create)) { await fs.WriteAsync(buf, 0, buf.Length); } Console.WriteLine("download: {0} => {1}", url, fileName); } catch (Exception ex) { Console.WriteLine("failed: {0}, {1}", url, ex.Message); } }; Task.WaitAll((from url in urls select download(url)).ToArray()); }
private static async Task<string> DownloadRawData(string url) { string cookieHeader = GetAllCookies_FireFox(StravaDomain); WebClient webClient = new WebClient(); webClient.Headers.Add(HttpRequestHeader.Cookie, cookieHeader); var res = await webClient.DownloadDataTaskAsync(new Uri(url)); return Encoding.UTF8.GetString(res); }
public static async Task <byte[]> DownloadDataAsync(string url) { using (var wc = new System.Net.WebClient()) { wc.Headers[HttpRequestHeader.UserAgent] = WII_USER_AGENT; wc.DownloadProgressChanged += DownloadProgressChanged; return(await wc.DownloadDataTaskAsync(new Uri(url))); } }
public async Task<AddResponse> AddAsync(AddRequest request) { using (var client = new WebClient()) { await client.DownloadDataTaskAsync(new Uri(this.url + "add?id=" + request.CalculatorId + "&value=" + request.Value)); } return new AddResponse(); }
public async Task<string> Load() { using (var client = new WebClient()) { var raw= await client.DownloadDataTaskAsync(m_url); return Encoding.UTF8.GetString(raw); } }
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; }
public Task<byte[]> LoadAsync(Uri uri) { using (var client = new WebClient()) { Task<byte[]> task = client.DownloadDataTaskAsync(uri); return task; } }
async void downloadAsync(object sender, System.EventArgs ea) { webClient = new WebClient (); //An large image url var url = new Uri ("http://photojournal.jpl.nasa.gov/jpeg/PIA15416.jpg"); byte[] bytes = null; webClient.DownloadProgressChanged += HandleDownloadProgressChanged; this.downloadButton.SetTitle ("Cancel",UIControlState.Normal); this.downloadButton.TouchUpInside -= downloadAsync; this.downloadButton.TouchUpInside += cancelDownload; infoLabel.Text = "Downloading..."; //Start download data using DownloadDataTaskAsync try{ bytes = await webClient.DownloadDataTaskAsync(url); } catch(TaskCanceledException){ Console.WriteLine ("Task Canceled!"); return; } catch(Exception e) { Console.WriteLine (e.ToString()); return; } string documentsPath = Environment.GetFolderPath (Environment.SpecialFolder.Personal); string localFilename = "downloaded.png"; string localPath = Path.Combine (documentsPath, localFilename); infoLabel.Text = "Download Complete"; //Save the image using writeAsync FileStream fs = new FileStream (localPath, FileMode.OpenOrCreate); await fs.WriteAsync (bytes, 0, bytes.Length); Console.WriteLine("localPath:"+localPath); //Resizing image is time costing, using async to avoid blocking the UI thread UIImage image = null; SizeF imageViewSize = imageView.Frame.Size; infoLabel.Text = "Resizing Image..."; await Task.Run( () => { image = UIImage.FromFile(localPath).Scale(imageViewSize); } ); Console.WriteLine ("Loaded!"); imageView.Image = image; infoLabel.Text = "Click Dowload button to download the image"; this.downloadButton.TouchUpInside -= cancelDownload; this.downloadButton.TouchUpInside += downloadAsync; this.downloadButton.SetTitle ("Download", UIControlState.Normal); this.downloadProgress.Progress = 0.0f; }
public async void DownloadHistory ( ImageView imageView,string url,ProgressBar Pbar =null) { if (string.IsNullOrEmpty(url)) return; try { int index = url.LastIndexOf ("/"); string localFilename = url.Substring (index + 1); var webClient = new WebClient (); var uri = new Uri (url); webClient.DownloadProgressChanged += (sender, e) => {if(Pbar!=null) Pbar.Progress=e.ProgressPercentage; }; documentsPath = System.Environment.GetFolderPath (System.Environment.SpecialFolder.Personal); localPath = System.IO.Path.Combine (documentsPath, localFilename); var localImage = new Java.IO.File (localPath); if (localImage.Exists ()) { var imgUri=Android.Net.Uri.Parse("file:"+localPath); imageView.SetImageURI(imgUri); } else { byte[] bytes = null; bytes = await webClient.DownloadDataTaskAsync (uri); FileStream fs = new FileStream (localPath, FileMode.Create); await fs.WriteAsync (bytes, 0, bytes.Length); fs.Close (); var imgUri=Android.Net.Uri.Parse("file:"+localPath); imageView.SetImageURI(imgUri); // teamBitmap = await BitmapFactory.DecodeByteArrayAsync (bytes, 0, bytes.Length); // imageView.SetImageBitmap (teamBitmap); } } catch (TaskCanceledException) { return; } catch (Exception) { return; } }
public static byte[] DownloadData(string url) { using (var wc = new System.Net.WebClient()) { wc.Headers[HttpRequestHeader.UserAgent] = WII_USER_AGENT; wc.DownloadProgressChanged += DownloadProgressChanged; var task = wc.DownloadDataTaskAsync(new Uri(url)); return(task.Result); } }
public async Task<byte[]> Retrieve(string storageKey) { var uri = _uriFormatter.FormatUri(storageKey); _logger.Debug("Reading blob {0} from {1}", storageKey, uri); using (var webClient = new WebClient()) { var result = await webClient.DownloadDataTaskAsync(uri); return result; } }
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; } return await client.DownloadDataTaskAsync(url); }
public void DownloadDataTaskAsyncTest() { var uri = new Uri("https://www.google.com"); var timout = new TimeSpan(0, 0, 30); var webClient = new WebClient(); var result = webClient.DownloadDataTaskAsync(uri, timout).Result; Assert.IsNotNull(result); Assert.AreEqual(typeof(byte[]), result.GetType()); }
public async Task<bool> FileExistsAsync(GitHubRepoSearchItem repo, string filePath) { var wc = new WebClient(); var url = $"https://raw.githubusercontent.com/{repo.FullName}/master/{filePath}"; try { var json = await wc.DownloadDataTaskAsync(url); return true; } catch (WebException) { return false; } }
public async Task LoadChangelog() { var downloader = new WebClient(); string version = await downloader.DownloadStringTaskAsync("http://battlelogium.github.io/Battlelogium/releaseinfo/releaseversion"); MemoryStream changenotes = new MemoryStream(await downloader.DownloadDataTaskAsync("http://battlelogium.github.io/Battlelogium/releaseinfo/releasenotes.rtf")); this.Dispatcher.Invoke(() => { new TextRange(changeLogBox.Document.ContentStart, changeLogBox.Document.ContentEnd).Load(changenotes, DataFormats.Rtf); this.versionLabel.Content = "Version " + version; }); }
public async Task<Bitmap> downloadAsync (string uri) { if (uri == null) return null; int index = uri.LastIndexOf ("/"); string localFilename = uri.Substring (index + 1); webClient = new WebClient (); var url = new Uri (uri); byte[] bytes = null; try { bytes = await webClient.DownloadDataTaskAsync (url); } catch (TaskCanceledException Ex) { Log.Error ("downloadAsync:", Ex.Message); return null; } catch (Exception Ex) { Log.Error ("downloadAsync:", Ex.Message); return null; } string documentsPath = System.Environment.GetFolderPath (System.Environment.SpecialFolder.Personal); string localPath = System.IO.Path.Combine (documentsPath, localFilename); //Sive the Image using writeAsync FileStream fs = new FileStream (localPath, FileMode.OpenOrCreate); await fs.WriteAsync (bytes, 0, bytes.Length); //Console.WriteLine("localPath:"+localPath); fs.Close (); BitmapFactory.Options options = new BitmapFactory.Options (); options.InJustDecodeBounds = true; await BitmapFactory.DecodeFileAsync (localPath, options); // options.InSampleSize = options.OutWidth > options.OutHeight ? options.OutHeight / imageview.Height : options.OutWidth / imageview.Width; options.InJustDecodeBounds = false; Bitmap bitmap = await BitmapFactory.DecodeFileAsync (localPath, options); return (bitmap); }
public async Task<IActionResult> Convert(ImageToConvert imageToConvert) { var result = string.Empty; if (!string.IsNullOrEmpty(imageToConvert.UrlOfTheImage)) { WebClient webClient = new WebClient(); var imageBytes = await webClient.DownloadDataTaskAsync(new Uri(imageToConvert.UrlOfTheImage)); result = ConvertToText(imageBytes); } return Json(result); }
/// <summary> /// Downloads a file from the Internet (http, https). If an exception occurs a /// null will be returned. /// </summary> /// <param name="remoteUrl"></param> public static async Task <byte[]> SafeDownloadFileAsync(string remoteUrl) { try { using var wc = new System.Net.WebClient(); return(await wc.DownloadDataTaskAsync(remoteUrl)); } catch { return(null); } }
public async Task <WebResult> Download(Url url) { //TODO: проверять content type перед закачкой var result = new WebResult { Url = url }; try { var rawdata = await _client.DownloadDataTaskAsync(url.ToString()); result.Data = Encoding .GetEncoding(GetCharset() ?? Encoding.UTF8.WebName) .GetString(rawdata); result.ErrorCode = 200; } catch (WebException ex) when(ex.Response is HttpWebResponse && ex.Status == WebExceptionStatus.ProtocolError && ex.Response != null) { result.ErrorCode = GetStatusCode(ex); } return(result); }
/// <summary> /// Scarica un file in asincrono. /// </summary> /// <param name="Url">L'Url da dove prelevare il file</param> /// <param name="Destination">La destinazione locale dove salvarlo</param> /// <param name="WriteOnBuffer">Se deve scaricare i dati (alcune estensioni hanno problemi con downloadfile)</param> public static async UniTask <bool> DownloadFileAsync(string Url, string Destination, bool WriteOnBuffer = false) { try { if (WriteOnBuffer) { System.Net.WebClient webClient = new System.Net.WebClient(); byte[] buffer = await webClient.DownloadDataTaskAsync(Url); File.WriteAllBytes(Destination, buffer); webClient.Dispose(); } else { System.Net.WebClient webClient = new System.Net.WebClient(); await webClient.DownloadFileTaskAsync(Url, Destination); webClient.Dispose(); } } catch (Exception e) { LogE("Utilities", "Errore DownloadFile: [" + e + "]"); return(false); } return(true); }
public async static Task LoadGeneratedMonsters() { //Console.WriteLine("test"); string url = "https://jsonplaceholder.typicode.com/photos"; System.Net.WebClient wc = new System.Net.WebClient(); byte[] raw = await(wc.DownloadDataTaskAsync(url)); string webData = System.Text.Encoding.UTF8.GetString(raw); JArray photos = JArray.Parse(webData); //Console.WriteLine("test"); foreach (var item in photos) { var idToken = item.SelectToken("id"); var titleToken = item.SelectToken("title"); //Console.WriteLine(e); int id = Int32.Parse(idToken.ToString()); _randomMonsters.Add(new Monster(MonsterID.GENERATED, titleToken.ToString(), 10, 10, 10, 10, 10)); } Console.WriteLine(_randomMonsters.Count); }
public Task <byte[]> DownloadDataTaskAsync(string address) { return(_webClient.DownloadDataTaskAsync(address)); }
public async Task<IActionResult> ProfileImage(string domain, string login) { using (var client = new WebClient()) { var uri = string.Format(_appSettings.Options.SharePointImageUrl, domain, login); var data = await client.DownloadDataTaskAsync(uri); return File(data, "image/jpeg"); } }
public Task<byte[]> DownloadUrl(string url) { var wc = new WebClient(); this.Log().Info("Downloading url: " + url); return this.WarnIfThrows(() => wc.DownloadDataTaskAsync(url), "Failed to download url: " + url); }