private void EndUpdateAsync(DeploymentManager dm, Exception error, bool cancelled) { Interlocked.Exchange(ref this._guard, 0); AsyncCompletedEventArgs e = new AsyncCompletedEventArgs(error, cancelled, (object)null); AsyncCompletedEventHandler completedEventHandler = (AsyncCompletedEventHandler)this.Events[ApplicationDeployment.updateCompletedKey]; if (completedEventHandler != null) { completedEventHandler((object)this, e); } if (dm == null) { return; } dm.ProgressChanged -= new DeploymentProgressChangedEventHandler(this.UpdateProgressChangedEventHandler); dm.BindCompleted -= new BindCompletedEventHandler(this.UpdateBindCompletedEventHandler); dm.SynchronizeCompleted -= new SynchronizeCompletedEventHandler(this.SynchronizeNullCompletedEventHandler); new NamedPermissionSet("FullTrust").Assert(); try { dm.Dispose(); } finally { CodeAccessPermission.RevertAssert(); } }
/// <summary>Downloads the resource with the specified URI to a local file, asynchronously.</summary> /// <param name="webClient">The WebClient.</param> /// <param name="address">The URI from which to download data.</param> /// <param name="fileName">The name of the local file that is to receive the data.</param> /// <returns>A Task that contains the downloaded data.</returns> public static Task DownloadFileTask(this WebClient webClient, Uri address, string fileName) { // Create the task to be returned var tcs = new TaskCompletionSource <object>(address); // Setup the callback event handler AsyncCompletedEventHandler handler = null; handler = (sender, e) => EAPCommon.HandleCompletion(tcs, e, () => null, () => webClient.DownloadFileCompleted -= handler); webClient.DownloadFileCompleted += handler; // Start the async work try { webClient.DownloadFileAsync(address, fileName, tcs); } catch (Exception exc) { // If something goes wrong kicking off the async work, // unregister the callback and cancel the created task webClient.DownloadFileCompleted -= handler; tcs.TrySetException(exc); } // Return the task that represents the async operation return(tcs.Task); }
public static void DownloadFileAsync(string fileLocation, DownloadProgressChangedEventHandler downloadHandler, AsyncCompletedEventHandler downloadCompletedHandler, string fileName) { General.IsUpdating = true; try { using (ByteGuardWebClient byteguardWebClient = new ByteGuardWebClient()) { byteguardWebClient.CookieJar = CookieContainer; byteguardWebClient.DownloadProgressChanged += downloadHandler; byteguardWebClient.DownloadFileCompleted += downloadCompletedHandler; Uri postUri = new Uri( String.Format("{0}process.php?act=downloadupdate&filename={1}", General.ByteGuardHost, fileName)); lock (LockObject) { byteguardWebClient.DownloadFileAsync(postUri, fileLocation); } } } catch { MessageBox.Show("Failed to download update, please try again shortly.", "Update Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } }
/// <inheritdoc/> public void AddAttachment(FileTransferInformation fileTransferInfo, AsyncCompletedEventHandler sendFileCompletedCallback, Uri uri, string friendlyName) { ValidateArg.NotNull(fileTransferInfo, nameof(fileTransferInfo)); if (string.IsNullOrEmpty(this.SessionOutputDirectory)) { if (EqtTrace.IsErrorEnabled) { EqtTrace.Error( "DataCollectionAttachmentManager.AddAttachment: Initialize not invoked."); } return; } if (!this.AttachmentSets.ContainsKey(uri)) { this.AttachmentSets.Add(uri, new AttachmentSet(uri, friendlyName)); } if (fileTransferInfo != null) { this.AddNewFileTransfer(fileTransferInfo, sendFileCompletedCallback, uri, friendlyName); } else { if (EqtTrace.IsErrorEnabled) { EqtTrace.Error("DataCollectionAttachmentManager.AddAttachment: Got unexpected message of type FileTransferInformationExtension."); } } }
public void Download(string dataPath, AsyncCompletedEventHandler callback) { try { using (WebClient client = new WebClient()) { FileInfo dest = new FileInfo(Path.Combine(dataPath, "Updates", this.Latest.FileName)); if (!dest.Directory.Exists) { dest.Directory.Create(); } client.DownloadFileCompleted += delegate(object sender, AsyncCompletedEventArgs e) { if (!e.Cancelled && (e.Error == null)) { this.Unzip(dest.FullName); callback(sender, e); } }; client.DownloadFileAsync(new Uri(this.Latest.FileUrl), dest.FullName); } } catch (WebException exception) { if (this.Error != null) { this.Error(this, new UnhandledExceptionEventArgs(exception, false)); } this.Status = UpdateStatus.Problem; } }
/// <summary> /// Downloads a file from the website using async /// </summary> /// <param name="URL">The URL to the file</param> /// <param name="path">The path to save the file at</param> /// <param name="method">The method to run once the download is done</param> /// <param name="useNewClient">Use a new client</param> /// <param name="client">A custom client(leave null to create a new one)</param> /// <returns>If the file was downloaded successfully</returns> public static bool DownloadFileAsync(string URL, string path, AsyncCompletedEventHandler method = null, bool useNewClient = true, WeebClient client = null) { try { if (useNewClient || client == null) { WeebClient wc = new WeebClient(); wc.DownloadFileCompleted += new AsyncCompletedEventHandler(OnDownloadFile); if (method != null) { wc.DownloadFileCompleted += method; } wc.DownloadFileAsync(new Uri(URL), path); return(true); } client.DownloadFileAsync(new Uri(URL), path); return(true); } catch (Exception ex) { PointBlankLogging.LogError("Failed to download file via async from " + URL, ex, false, false); return(false); } }
public bool StartDownload(AsyncCompletedEventHandler dlFinishedCallback, DownloadProgressChangedEventHandler dlProgressCallback, string URL, string SavePath) { Uri uri; try { uri = new Uri(URL); } catch (Exception) { return(false); } m_client.DownloadFileCompleted += dlFinishedCallback; m_client.DownloadProgressChanged += dlProgressCallback; int chrindex = SavePath.LastIndexOf(@"/"); if (chrindex == -1) { chrindex = SavePath.LastIndexOf(@"\"); } string Path = SavePath.Substring(0, chrindex); System.IO.Directory.CreateDirectory(Path); m_client.DownloadFileAsync(uri, MyToolkit.ValidPath(SavePath)); return(true); }
private void GetChangeLogCompleted(object sender, System.ComponentModel.AsyncCompletedEventArgs e) { if (InvokeRequired) { AsyncCompletedEventHandler myDelegate = new AsyncCompletedEventHandler(GetChangeLogCompleted); Invoke(myDelegate, new object[] { sender, e }); return; } try { _appUpdate.GetChangeLogCompletedEvent -= GetChangeLogCompleted; if (e.Cancelled) { return; } if (e.Error != null) { throw (e.Error); } txtChangeLog.Text = _appUpdate.ChangeLog; } catch (Exception ex) { Runtime.MessageCollector.AddExceptionMessage(Language.strUpdateGetChangeLogFailed, ex); } }
public static void DownloadFileAsync(string fileLocation, DownloadProgressChangedEventHandler downloadHandler, AsyncCompletedEventHandler downloadCompletedHandler, string programid = null) { try { using (ByteGuardWebClient byteguardWebClient = new ByteGuardWebClient()) { byteguardWebClient.CookieJar = CookieContainer; byteguardWebClient.DownloadProgressChanged += downloadHandler; //byteguardWebClient.DownloadDataCompleted += downloadCompletedHandler; byteguardWebClient.DownloadFileCompleted += downloadCompletedHandler; Uri postUri = new Uri( String.Format("{0}process.php?act=dlprogram&pid={1}", Variables.ByteGuardHost, programid)); lock (LockObject) { byteguardWebClient.DownloadFileAsync(postUri, fileLocation); } } } catch { Variables.Containers.Main.SetStatus("Failed to download program, please try again shortly.", 1); } }
public Form1() { InitializeComponent(); thread1 = new Thread(new ThreadStart(this.threadEntryPoint)); thread1_Thread1Completed += new AsyncCompletedEventHandler(thread1_Thread1Completed); }
private void GetChangeLogCompleted(object sender, AsyncCompletedEventArgs e) { if (InvokeRequired) { var myDelegate = new AsyncCompletedEventHandler(GetChangeLogCompleted); Invoke(myDelegate, sender, e); return; } try { _appUpdate.GetChangeLogCompletedEvent -= GetChangeLogCompleted; if (e.Cancelled) { return; } if (e.Error != null) { throw e.Error; } txtChangeLog.Text = _appUpdate.ChangeLog.Replace("\n", Environment.NewLine); } catch (Exception ex) { Runtime.MessageCollector.AddExceptionMessage(Language.strUpdateGetChangeLogFailed, ex); } }
/*! * \brief Download the update installer to a user-defined file without blocking the current thread. * * \param downloadCompleteFunc Function to be called when the download finishes. * * \return True if the download process was successfully started, and false if the * end-user canceled the dialog choosing where to save the downloading file to, or an * error occurred. */ public bool DownloadUpdateAsync(AsyncCompletedEventHandler downloadCompleteFunc) { DownloadFileCompleted += downloadCompleteFunc; var saveFile = new SaveFileDialog { Title = "Save Download As", Filter = "Windows Installer (*.msi)|*.msi", OverwritePrompt = true, FileName = "vp_lottery_setup", DefaultExt = "msi", InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments) }; var filedChosen = saveFile.ShowDialog(); if (filedChosen == null || !filedChosen.Value) { return(false); } // Open and close file to ensure that it exists before downloading the data into it. var targetFile = saveFile.OpenFile(); targetFile.Close(); try { UpdateInstallerFile = saveFile.FileName; DownloadFileTaskAsync(AppMsiUri, UpdateInstallerFile); return(true); } catch (Exception e) { LogError(e.Message + " Target URI: " + AppMsiUri); return(false); } }
private void GetAnnouncementInfoCompleted(object sender, AsyncCompletedEventArgs e) { if (InvokeRequired) { AsyncCompletedEventHandler myDelegate = new AsyncCompletedEventHandler(GetAnnouncementInfoCompleted); Invoke(myDelegate, new object[] { sender, e }); return; } try { _appUpdate.GetAnnouncementInfoCompletedEvent -= GetAnnouncementInfoCompleted; if (e.Cancelled) { return; } if (e.Error != null) { throw (e.Error); } webBrowser.Navigate(_appUpdate.CurrentAnnouncementInfo.Address); } catch (Exception ex) { Runtime.MessageCollector.AddExceptionMessage(Language.strUpdateGetAnnouncementInfoFailed, ex); } }
/// <summary>Downloads the resource with the specified URI to a local file, asynchronously.</summary> /// <param name="webClient">The WebClient.</param> /// <param name="address">The URI from which to download data.</param> /// <param name="fileName">The name of the local file that is to receive the data.</param> /// <returns>A Task that contains the downloaded data.</returns> public static Task DownloadFileTaskAsync(this WebClient webClient, Uri address, string fileName) { // Create the task to be returned var tcs = new TaskCompletionSource <object>(address); // Setup the callback event handler AsyncCompletedEventHandler completedHandler = null; completedHandler = (sender, e) => TaskServices.HandleEapCompletion(tcs, true, e, () => null, () => { webClient.DownloadFileCompleted -= completedHandler; }); webClient.DownloadFileCompleted += completedHandler; // Start the async operation. try { webClient.DownloadFileAsync(address, fileName, tcs); } catch { webClient.DownloadFileCompleted -= completedHandler; throw; } // Return the task that represents the async operation return(tcs.Task); }
protected override async Task <bool> CheckUpdateCore() { UpdateCheckInfo info = null; ApplicationDeployment ad = ApplicationDeployment.CurrentDeployment; try { info = ad.CheckForDetailedUpdate(); } catch (DeploymentDownloadException) { return(false); } catch (InvalidDeploymentException) { return(false); } catch (InvalidOperationException) { return(false); } if (!info.UpdateAvailable) { return(false); } bool handled = false; AsyncCompletedEventHandler handler = (sender, e) => { handled = true; }; ad.UpdateCompleted += handler; ad.UpdateAsync(); while (!handled) { await Task.Delay(100); } ad.UpdateCompleted -= handler; return(true); }
public void AddAttachmentsShouldAddFilesCorrespondingToDifferentDataCollectors() { var filename = "filename.txt"; var filename1 = "filename1.txt"; File.WriteAllText(Path.Combine(TempDirectoryPath, filename), string.Empty); File.WriteAllText(Path.Combine(TempDirectoryPath, filename1), string.Empty); this.attachmentManager.Initialize(this.sessionId, TempDirectoryPath, this.messageSink.Object); var datacollectioncontext = new DataCollectionContext(this.sessionId); var friendlyName = "TestDataCollector"; var uri = new Uri("datacollector://Company/Product/Version"); var uri1 = new Uri("datacollector://Company/Product/Version1"); EventWaitHandle waitHandle = new AutoResetEvent(false); var handler = new AsyncCompletedEventHandler((a, e) => { waitHandle.Set(); }); var dataCollectorDataMessage = new FileTransferInformation(datacollectioncontext, Path.Combine(TempDirectoryPath, filename), false); this.attachmentManager.AddAttachment(dataCollectorDataMessage, handler, uri, friendlyName); // Wait for file operations to complete waitHandle.WaitOne(Timeout); waitHandle.Reset(); dataCollectorDataMessage = new FileTransferInformation(datacollectioncontext, Path.Combine(TempDirectoryPath, filename1), false); this.attachmentManager.AddAttachment(dataCollectorDataMessage, handler, uri1, friendlyName); // Wait for file operations to complete waitHandle.WaitOne(Timeout); Assert.AreEqual(1, this.attachmentManager.AttachmentSets[datacollectioncontext][uri].Attachments.Count); Assert.AreEqual(1, this.attachmentManager.AttachmentSets[datacollectioncontext][uri1].Attachments.Count); }
public void GetAttachmentsShouldNotReturnAttachmentsAfterCancelled() { var fileHelper = new Mock <IFileHelper>(); var testableAttachmentManager = new TestableDataCollectionAttachmentManager(fileHelper.Object); var attachmentPath = Path.Combine(TempDirectoryPath, "filename.txt"); File.WriteAllText(attachmentPath, string.Empty); var datacollectioncontext = new DataCollectionContext(this.sessionId); var friendlyName = "TestDataCollector"; var uri = new Uri("datacollector://Company/Product/Version"); var dataCollectorDataMessage = new FileTransferInformation(datacollectioncontext, attachmentPath, true); var waitHandle = new AutoResetEvent(false); var handler = new AsyncCompletedEventHandler((a, e) => { Assert.Fail("Handler shouldn't be called since operation is canceled."); }); // We cancel the operation in the actual operation. This ensures the follow up task to is never called, attachments // are not added. Action cancelAddAttachment = () => testableAttachmentManager.Cancel(); fileHelper.Setup(fh => fh.MoveFile(It.IsAny <string>(), It.IsAny <string>())).Callback(cancelAddAttachment); testableAttachmentManager.Initialize(this.sessionId, TempDirectoryPath, this.messageSink.Object); testableAttachmentManager.AddAttachment(dataCollectorDataMessage, handler, uri, friendlyName); // Wait for the attachment transfer tasks to complete var result = testableAttachmentManager.GetAttachments(datacollectioncontext); Assert.AreEqual(0, result[0].Attachments.Count); }
IEnumerator <Task <AsyncCompletedEventArgs> > FetchOperationAsyncHelper(object state, CancellationToken token, int timeout, Action continuator) { var tcs = new TaskCompletionSource <AsyncCompletedEventArgs>(); // prepare the timeout CancellationToken newToken; if (timeout != Timeout.Infinite) { var cts = CancellationTokenSource.CreateLinkedTokenSource(token); TaskExt.CancelAfterEx(cts, timeout * 1000); newToken = cts.Token; } else { newToken = token; } /* handle completion */ AsyncCompletedEventHandler handler = (sender, args) => { if (args.Cancelled) { tcs.TrySetCanceled(); } else if (args.Error != null) { tcs.SetException(args.Error); } else { tcs.SetResult(args); } }; this.FetchOperationCompleted += handler; try { using (newToken.Register(() => { try { tcs.SetCanceled(); } catch (InvalidOperationException) { /* cancel when already finished, does not matter */ #if DEBUG Tracing.WarningDAL("Canceled async db operation, when it has already completed."); #endif } }, useSynchronizationContext: false)) { this.StartFetchOperation(state); yield return(tcs.Task.Continuation(continuator)); } } finally { this.FetchOperationCompleted -= handler; } }
/// <summary> /// This method can be used to download binary data from a URL. It is an ansynchronous method that can report progress. /// </summary> /// <returns></returns> public async Task <byte[]> GetBytesFromUrl( string url, ICredentials credential = null, DownloadProgressChangedEventHandler downloadProgressHandler = null, AsyncCompletedEventHandler downloadCompleteHandler = null) { using (var webClient = new WebClient()) { if (credential != null) { webClient.Credentials = credential; } if (downloadProgressHandler != null) { webClient.DownloadProgressChanged += downloadProgressHandler; } if (downloadCompleteHandler != null) { webClient.DownloadFileCompleted += downloadCompleteHandler; } return(await webClient.DownloadDataTaskAsync(url)); } }
/// <inheritdoc/> public void AddAttachment(FileTransferInformation fileTransferInfo, AsyncCompletedEventHandler sendFileCompletedCallback, Uri uri, string friendlyName) { ValidateArg.NotNull(fileTransferInfo, nameof(fileTransferInfo)); if (string.IsNullOrEmpty(this.SessionOutputDirectory)) { if (EqtTrace.IsErrorEnabled) { EqtTrace.Error( "DataCollectionAttachmentManager.AddAttachment: Initialize not invoked."); } return; } if (!this.AttachmentSets.ContainsKey(fileTransferInfo.Context)) { var uriAttachmentSetMap = new Dictionary <Uri, AttachmentSet>(); this.AttachmentSets.Add(fileTransferInfo.Context, uriAttachmentSetMap); this.attachmentTasks.Add(fileTransferInfo.Context, new List <Task>()); } if (!this.AttachmentSets[fileTransferInfo.Context].ContainsKey(uri)) { this.AttachmentSets[fileTransferInfo.Context].Add(uri, new AttachmentSet(uri, friendlyName)); } this.AddNewFileTransfer(fileTransferInfo, sendFileCompletedCallback, uri, friendlyName); }
private void GetUpdateInfoCompleted(object sender, AsyncCompletedEventArgs e) { if (InvokeRequired) { AsyncCompletedEventHandler myDelegate = GetUpdateInfoCompleted; Invoke(myDelegate, sender, e); return; } try { _appUpdate.GetUpdateInfoCompletedEvent -= GetUpdateInfoCompleted; btnTestProxy.Enabled = true; btnTestProxy.Text = Language.strButtonTestProxy; if (e.Cancelled) { return; } if (e.Error != null) { throw e.Error; } CTaskDialog.ShowCommandBox(this, Convert.ToString(Application.ProductName), Language.strProxyTestSucceeded, "", Language.strButtonOK, false); } catch (Exception ex) { CTaskDialog.ShowCommandBox(this, Convert.ToString(Application.ProductName), Language.strProxyTestFailed, MiscTools.GetExceptionMessageRecursive(ex), "", "", "", Language.strButtonOK, false, ESysIcons.Error, 0); } }
/// <summary> /// Create an instance of the DatabaseAutomationRunner window /// </summary> public DatabaseAutomationRunner(ModpackSettings modpackSettings, Logfiles logfile) : base(modpackSettings, logfile) { InitializeComponent(); DownloadProgressChanged = WebClient_DownloadProgressChanged; DownloadDataCompleted = WebClient_DownloadDataComplted; DownloadFileCompleted = WebClient_TransferFileCompleted; UploadFileCompleted = WebClient_UploadFileCompleted; UploadProgressChanged = WebClient_UploadProgressChanged; RelhaxProgressChanged = RelhaxProgressReport_ProgressChanged; ProgressChanged = GenericProgressChanged; Settings = AutomationSettings; //https://stackoverflow.com/questions/7712137/array-containing-methods settingsMethods = new Action[] { () => OpenLogWindowOnStartupSetting_Click(null, null), () => BigmodsUsernameSetting_TextChanged(null, null), () => BigmodsPasswordSetting_TextChanged(null, null), () => DumpParsedMacrosPerSequenceRunSetting_Click(null, null), () => DumpEnvironmentVariablesAtSequenceStartSetting_Click(null, null), () => SuppressDebugMessagesSetting_Click(null, null), () => AutomamtionDatabaseSelectedBranchSetting_TextChanged(null, null), () => SelectDBSaveLocationSetting_TextChanged(null, null), () => UseLocalRunnerDatabaseSetting_Click(null, null), () => LocalRunnerDatabaseRootSetting_TextChanged(null, null), () => SelectWoTInstallLocationSetting_TextChanged(null, null) }; }
/// <see cref="IAsyncWebClient.DownloadFileAsync"/> public Task DownloadFileAsync(Uri address, string fileName, IProgress<DownloadProgressChangedEventArgs> progress, CancellationToken cancellationToken) { cancellationToken.Register(() => _webClient.CancelAsync()); var cookie = Guid.NewGuid(); var tcs = new TaskCompletionSource<object>(); DownloadProgressChangedEventHandler progressHandler = CreateProgressHandler(cookie, progress); if (progress != null) _webClient.DownloadProgressChanged += progressHandler; AsyncCompletedEventHandler completedHandler = null; completedHandler = (o, e) => { if (!Equals(e.UserState, cookie)) return; _webClient.DownloadProgressChanged -= progressHandler; _webClient.DownloadFileCompleted -= completedHandler; tcs.TrySetFromEventArgs(e); }; _webClient.DownloadFileCompleted += completedHandler; _webClient.DownloadFileAsync(address, fileName, cookie); return tcs.Task; }
/// <summary> /// Handle finished download, move file from temporary to target location /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void Finished(object sender, AsyncCompletedEventArgs e) { try { Logger.Log(LogLevel.Info, "FileDownloadProgressBar", "Download finished!", Url); // Move to the correct location if (File.Exists(Targetlocation)) { File.Delete(Targetlocation); } File.Move(_tmplocation, Targetlocation); } catch (Exception ex) { // TODO: figure out what locks these files Logger.Log(LogLevel.Severe, "FileDownloadProgressBar", "Could not replace file " + Targetlocation, ex.Message); } AsyncCompletedEventHandler handler = DownloadCompleted; if (handler != null) { handler(sender, e); } }
public void AddAttachmentShouldAddNewFileTransferAndCopyFileToOutputDirectoryIfDeleteFileIsFalse() { var filename = "filename.txt"; File.WriteAllText(Path.Combine(TempDirectoryPath, filename), string.Empty); this.attachmentManager.Initialize(this.sessionId, TempDirectoryPath, this.messageSink.Object); var datacollectioncontext = new DataCollectionContext(this.sessionId); var friendlyName = "TestDataCollector"; var uri = new Uri("datacollector://Company/Product/Version"); EventWaitHandle waitHandle = new AutoResetEvent(false); var handler = new AsyncCompletedEventHandler((a, e) => { waitHandle.Set(); }); var dataCollectorDataMessage = new FileTransferInformation(datacollectioncontext, Path.Combine(TempDirectoryPath, filename), false); this.attachmentManager.AddAttachment(dataCollectorDataMessage, handler, uri, friendlyName); // Wait for file operations to complete waitHandle.WaitOne(Timeout); Assert.IsTrue(File.Exists(Path.Combine(TempDirectoryPath, filename))); Assert.IsTrue(File.Exists(Path.Combine(TempDirectoryPath, this.sessionId.Id.ToString(), filename))); Assert.AreEqual(1, this.attachmentManager.AttachmentSets[datacollectioncontext][uri].Attachments.Count); }
private static FileInfo DownloadFileFromUrlToPathRaw(string url, string path, WebClient webClient) { if (ProgressDisplay.CanUseConsole) { using (var display = new ProgressDisplay(0)) { DownloadProgressChangedEventHandler downloadProgress = (sender, e) => { display.Update(e.BytesReceived, e.TotalBytesToReceive); }; AsyncCompletedEventHandler downloadCompleted = (sender, e) => { lock (e.UserState) { Monitor.Pulse(e.UserState); } }; var syncObj = new object(); lock (syncObj) { webClient.DownloadProgressChanged += downloadProgress; webClient.DownloadFileCompleted += downloadCompleted; webClient.DownloadFileAsync(new Uri(url), path, syncObj); Monitor.Wait(syncObj); webClient.DownloadProgressChanged -= downloadProgress; webClient.DownloadFileCompleted -= downloadCompleted; } } } else { AsyncCompletedEventHandler downloadCompleted = (sender, e) => { lock (e.UserState) { if (e.Error != null) { Log.Error("Download failed."); Log.Exception(e.Error); } Monitor.Pulse(e.UserState); } }; var syncObj = new object(); lock (syncObj) { webClient.DownloadFileCompleted += downloadCompleted; webClient.DownloadFileAsync(new Uri(url), path, syncObj); Monitor.Wait(syncObj); webClient.DownloadFileCompleted -= downloadCompleted; } } return(new FileInfo(path)); }
//Download File Async custom method public void DldFile(string url, string fileName, string localPath, AsyncCompletedEventHandler completedName, DownloadProgressChangedEventHandler progressName) { WebClient webClient = new WebClient(); webClient.DownloadFileAsync(new Uri(url), localPath + "\\" + fileName); webClient.DownloadFileCompleted += new AsyncCompletedEventHandler(completedName); webClient.DownloadProgressChanged += new DownloadProgressChangedEventHandler(progressName); }
public void DownloadInstaller(DownloadProgressChangedEventHandler onData, AsyncCompletedEventHandler onFinish) { _downloader.DownloadProgressChanged += onData; _downloader.DownloadFileCompleted += onFinish; _downloader.DownloadFileAsync(_installerURI, InstallerFile); }
public static ApplicationDeployment DoUpdateAsync(AsyncCompletedEventHandler onComplete = null, DeploymentProgressChangedEventHandler onProgress = null) { var ad = ApplicationDeployment.CurrentDeployment; if (onComplete != null) ad.UpdateCompleted += onComplete; if (onProgress != null) ad.UpdateProgressChanged += onProgress; ad.UpdateAsync(); return ad; }
private void GetImagesinUrl1(HttpContext context) { string url = context.Request.QueryString["url"]; Regex img = new Regex("<img.+?src=[\"'](.+?)[\"'].+?>", RegexOptions.IgnoreCase); Regex src = new Regex(@"src=(?:(['""])(?<src>(?:(?!\1).)*)\1|(?<src>[^\s>]+))", RegexOptions.IgnoreCase | RegexOptions.Singleline); WebClient source = new WebClient(); string value = source.DownloadString(new Uri(url)); if (!string.IsNullOrEmpty(value)) { MatchCollection matches = img.Matches(value); if (matches.Count > 0) { string rpath = Common.RelTemp + Common.UserID; string path = Common.Temp + Common.UserID; if (!Directory.Exists(path)) { Directory.CreateDirectory(path); } else { string[] files = Directory.GetFiles(path); foreach (string file in files) { File.Delete(file); } } int i = 0; Dictionary <int, bool> _dict = new Dictionary <int, bool>(); List <string> paths = new List <string>(); AsyncCompletedEventHandler callback = (sender, e) => { dynamic dyn = (dynamic)e.UserState; _dict[dyn.i] = true; string rfn = rpath + dyn.i + ".jpg"; paths.Add(rfn); }; foreach (Match match in matches) { string imgUrl = match.Groups[1].Value; WebClient client = new WebClient(); client.DownloadFileCompleted += callback; string fn = path + "\\" + i + ".jpg"; dynamic dyn = new ExpandoObject(); dyn.fn = fn; dyn.i = i; client.DownloadFileAsync(new Uri(imgUrl), fn, dyn); _dict.Add(i, false); i++; } while (_dict.ContainsValue(false)) { Thread.Sleep(500); } context.WriteJsonP(JsonConvert.SerializeObject(paths, Formatting.Indented, Common.JsonSerializerSettings)); } } }
public async Task <bool> DownloadPodcastAsync( IPodcastEpisode episode, string directoryOut, AsyncCompletedEventHandler completedDownloadEvent = null, DownloadProgressChangedEventHandler downloadProgressChangedEvent = null, bool downloadInsertions = false) { try { if (string.IsNullOrEmpty(directoryOut)) { return(false); } if (!_fileHelper.DirectoryExists(directoryOut)) { _fileHelper.CreateDirectory(directoryOut); } if (episode is Episode naoOuvoEpisode && _fileHelper.DirectoryExists(directoryOut)) { var archiveName = naoOuvoEpisode.Url.Substring(naoOuvoEpisode.Url.LastIndexOf("/") + 1); if (currentFilesDownloading.Any(name => name.Equals(archiveName, StringComparison.CurrentCultureIgnoreCase))) { return(false); } var httpclient = new HttpClient() { Timeout = (new TimeSpan(5, 0, 0)) }; var client = new WebApiClient(httpclient, _fileHelper); currentFilesDownloading.Add(archiveName); directoryOut = directoryOut.EndsWith("\\") ? directoryOut : directoryOut + "\\"; if (downloadInsertions) { await DownloadNaoOuvoInsertions(naoOuvoEpisode, directoryOut, archiveName); } var filePath = string.Concat(directoryOut, archiveName); await client.GetAsync(naoOuvoEpisode.Url, filePath); currentFilesDownloading.Remove(archiveName); completedDownloadEvent?.Invoke(null, null); return(true); } } catch (Exception ex) { Debug.WriteLine($"Error on NaoOuvo download.\n\nDetails{ex.Message}"); return(false); } return(false); }
public static void FileRequestAsync(string url, string outputFile, DownloadProgressChangedEventHandler progressCallback, AsyncCompletedEventHandler completeCallback) { var wc = new WebClient(); if (_proxy != null) wc.Proxy = _proxy; wc.DownloadFileCompleted += completeCallback; wc.DownloadProgressChanged += progressCallback; wc.DownloadFileAsync(new System.Uri(url), outputFile); }
public SizePropertyBag(IVirtualFolder owner, AsyncCompletedEventHandler completed) { if (owner is ICloneable) { this.FOwner = (IVirtualFolder) ((ICloneable) owner).Clone(); } else { this.FOwner = owner; } this.FOwnerParent = owner.Parent as IVirtualCachedFolder; this.FCompleted = completed; }
/// <summary> /// Загружает файл (Асинхронно) /// </summary> /// <param name="saveToFileName"></param> /// <param name="url"></param> /// <param name="callback"></param> /// <param name="onProgress"></param> public static void loadFileAsync(String saveToFileName, String url, AsyncCompletedEventHandler callback, DownloadProgressChangedEventHandler onProgress) { WebClient wc = new WebClient(); wc.OpenReadCompleted += new OpenReadCompletedEventHandler((Object sender, OpenReadCompletedEventArgs e) => { //throw new NotImplementedException(); //FileStream //File.WriteAllBytes(); }); if (onProgress != null) wc.DownloadProgressChanged += onProgress; wc.OpenReadAsync(new Uri(url, UriKind.RelativeOrAbsolute)); }
public async Task DownloadAudioAync(Song song, string path, DownloadProgressChangedEventHandler ProgressChanged, AsyncCompletedEventHandler DownloadSongCallback) { try { WebClient Client = new WebClient(); hashCodeConnection.Add(Client.GetHashCode(), song.GetHashCode()); Client.DownloadFileCompleted += new AsyncCompletedEventHandler(DownloadSongCallback); Client.DownloadFileCompleted += new AsyncCompletedEventHandler(DownloadFileCallback); Client.DownloadProgressChanged += new DownloadProgressChangedEventHandler(ProgressChanged); await Client.DownloadFileTaskAsync(song.Uri, path); } catch { } }
public static void UpdateList(bool silent, bool installedOnly, DownloadProgressChangedEventHandler downloadProgressChanged, AsyncCompletedEventHandler downloadFileCompleted) { if (!installedOnly) { DownloadExtensionIndex(downloadProgressChanged, downloadFileCompleted); } DownloadInfo dlg = new DownloadInfo(); dlg.silent = silent; dlg.installedOnly = installedOnly; if (dlg.ShowDialog() == DialogResult.OK && !installedOnly) { ApplicationSettings.Instance.LastUpdate = DateTime.Now; ApplicationSettings.Instance.Save(); } }
/// <summary> /// Загружает файл (Асинхронно) /// </summary> /// <param name="pToFileName"></param> /// <param name="pURL"></param> /// <param name="pOnCmpltHndlr"></param> /// <param name="pOnPrgHndlr"></param> public static void loadFileAsync(String pToFileName, String pURL, AsyncCompletedEventHandler pOnCmpltHndlr, DownloadProgressChangedEventHandler pOnPrgHndlr) { WebClient wc = new WebClient(); if(pOnPrgHndlr != null) wc.DownloadProgressChanged += pOnPrgHndlr; wc.DownloadFileCompleted += new AsyncCompletedEventHandler((object sender, AsyncCompletedEventArgs e) => { if(pOnCmpltHndlr != null) pOnCmpltHndlr(sender, e); }); wc.Headers.Set(HttpRequestHeader.Cookie, ajaxUTL.csSessionIdName+"="+ajaxUTL.sessionID.Value); String vURL = pURL + "&pdummy=" + new Guid().ToString(); wc.DownloadFileAsync(new Uri(vURL), pToFileName); }
public ImageProcessingManager() { processWorkerDelegate = new Action<Queue<KeyValuePair<string, string>>, IEnumerable<IProcessingPlugin>, IOutputPlugin, AsyncOperation>(ProcessWorker); processAsyncTaskProgressChangedDelegate = new SendOrPostCallback(ProcessAsyncTaskProgressChanged); processAsyncProgressChangedDelegate = new SendOrPostCallback(ProcessAsyncProgressChanged); processAsyncStateChangedDelegate = new SendOrPostCallback(ProcessAsyncStateChanged); processAsyncCompletedDelegate = new SendOrPostCallback(ProcessAsyncCompleted); processingProgressForm_CancelProcessDelegate = new EventHandler<AsyncEventArgs>(processingProgressForm_CancelProcess); imageProcessor.ProcessProgressChanged += new ProgressChangedEventHandler(imageProcessor_ProcessProgressChanged); imageProcessor.ProcessCompleted += new AsyncCompletedEventHandler(imageProcessor_ProcessCompleted); ProcessTaskProgressChanged += new EventHandler<ProcessTaskProgressChangedEventArgs>(ImageProcessingManager_ProcessTaskProgressChanged); ProcessProgressChanged += new ProgressChangedEventHandler(ImageProcessingManager_ProcessProgressChanged); ProcessStateChanged += new EventHandler<ProcessStateChangedEventArgs>(ImageProcessingManager_ProcessStateChanged); ProcessCompleted += new AsyncCompletedEventHandler(ImageProcessingManager_ProcessCompleted); }
public Status DownloadSong(List<Song> listToDownload, DownloadProgressChangedEventHandler ProgressChanged, AsyncCompletedEventHandler DownloadSongCallback) { string folderName = Environment.GetFolderPath(Environment.SpecialFolder.MyMusic); string pathString = Path.Combine(folderName, "VVKMusic"); if (!File.Exists(pathString)) Directory.CreateDirectory(pathString); string folder = Environment.GetFolderPath(Environment.SpecialFolder.MyMusic) + @"\VVKMusic\"; count = listToDownload.Count; foreach (Song song in listToDownload) { string fileName = song.Artist + "-" + song.Title + ".mp3"; if (DownloadAudioAync(song, @folder + fileName, ProgressChanged, DownloadSongCallback).Exception != null) { return Status.Error; } song.DownloadedUri = new Uri(@folder + @fileName); } return Status.Ok; }
private void DownloadFile(Uri remoteUri, string localDest, AsyncCompletedEventHandler finished=null) { using (var downloadClient = new WebClient ()) { try { FileHelper.EnsureFileDirExists (localDest); logger.DebugFormat ("Downloading file from {0} to {1}", remoteUri, localDest); downloadClient.DownloadProgressChanged += onProgressChanged; downloadClient.DownloadFileCompleted += finished ?? onFileDownloaded; downloadClient.DownloadFileAsync (remoteUri, localDest); onDownloadStarted(); } catch (Exception ex) { logger.Fatal ("Downloading update failed", ex); onDownloadFailed (ex); } } }
public async Task<bool> DownloadUpdate(DownloadProgressChangedEventHandler progressEventHandler, AsyncCompletedEventHandler progressCompleteEventHandler) { try { if (Url != null && FileName != null) { string filePath = $"Res\\{FileName}.zip"; //We download our update. //HttpClient client = new HttpClient(); WebClient wclient = new WebClient(); //var input = await client.GetByteArrayAsync(Url); //We Recreate our previous Res Folder if (Directory.Exists("Res")) Directory.Delete("Res", true); Directory.CreateDirectory("Res"); //using (var fileStream = File.Create(filePath)) //{ // fileStream.Write(input, 0, input.Length); //} wclient.DownloadProgressChanged += progressEventHandler; wclient.DownloadFileCompleted += progressCompleteEventHandler; wclient.DownloadFileAsync(new Uri(Url), filePath); return File.Exists(filePath); } else { //Something went wrong. return false; } } catch (Exception) { //Something really went wrong. return false; } }
static void DownloadExtensionIndex(DownloadProgressChangedEventHandler downloadProgressChanged, AsyncCompletedEventHandler downloadFileCompleted) { DownloadFile dlg = null; try { tempUpdateIndex = Path.GetTempFileName(); dlg = new DownloadFile(); if (downloadProgressChanged != null) dlg.Client.DownloadProgressChanged += downloadProgressChanged; if (downloadFileCompleted != null) dlg.Client.DownloadFileCompleted += downloadFileCompleted; dlg.Client.DownloadFileCompleted += UpdateIndex_DownloadFileCompleted; dlg.StartDownload(UpdateIndexUrl, tempUpdateIndex); } catch (Exception ex) { MessageBox.Show(ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } finally { if (downloadProgressChanged != null) dlg.Client.DownloadProgressChanged -= downloadProgressChanged; if (downloadFileCompleted != null) dlg.Client.DownloadFileCompleted -=downloadFileCompleted; dlg.Client.DownloadFileCompleted -= UpdateIndex_DownloadFileCompleted; File.Delete(tempUpdateIndex); } }
/// <summary> /// Downloads a file async /// </summary> /// <param name="downloadLink"></param> /// <param name="filename"></param> /// <param name="onProgress">can be null</param> /// <param name="onComplete">can be null</param> public static void DownloadFileAsync(string downloadLink, string filename, DownloadProgressChangedEventHandler onProgress, AsyncCompletedEventHandler onComplete) { WebClient webClient = new WebClient(); try { MainConsole.Instance.Warn("Downloading new file from " + downloadLink + " now into file " + filename + "."); if (onProgress != null) webClient.DownloadProgressChanged += onProgress; if (onComplete != null) webClient.DownloadFileCompleted += onComplete; webClient.DownloadFileAsync(new Uri(downloadLink), filename); } catch (Exception) { } }
private void FileDownload_Load(object sender, EventArgs e) { ProgressChanged += new DownloadProgressChangedEventHandler(FileDownload_ProgressChanged); DownloadComplete += new AsyncCompletedEventHandler(FileDownload_DownloadComplete); }
public static string GetPackageLocation(PackageClass packageClass, DownloadProgressChangedEventHandler downloadProgressChanged, AsyncCompletedEventHandler downloadFileCompleted) { string newPackageLoacation = packageClass.GeneralInfo.Location; if (!File.Exists(newPackageLoacation)) { newPackageLoacation = packageClass.LocationFolder + packageClass.GeneralInfo.Id + ".mpe2"; if (!File.Exists(newPackageLoacation)) { if (!string.IsNullOrEmpty(packageClass.GeneralInfo.OnlineLocation)) { DownloadFile dlg = null; try { newPackageLoacation = Path.GetTempFileName(); dlg = new DownloadFile(); if (downloadProgressChanged != null) dlg.Client.DownloadProgressChanged += downloadProgressChanged; if (downloadFileCompleted != null) dlg.Client.DownloadFileCompleted += downloadFileCompleted; dlg.StartDownload(packageClass.GeneralInfo.OnlineLocation, newPackageLoacation); } catch (Exception ex) { MessageBox.Show(ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } finally { if (downloadProgressChanged != null) dlg.Client.DownloadProgressChanged -= downloadProgressChanged; if (downloadFileCompleted != null) dlg.Client.DownloadFileCompleted -= downloadFileCompleted; } } } } return newPackageLoacation; }
private void GetUpdateInfoCompleted(object sender, AsyncCompletedEventArgs e) { if (InvokeRequired) { var myDelegate = new AsyncCompletedEventHandler(GetUpdateInfoCompleted); Invoke(myDelegate, sender, e); return; } try { _appUpdate.GetUpdateInfoCompletedEvent -= GetUpdateInfoCompleted; lblInstalledVersion.Text = Application.ProductVersion; lblInstalledVersion.Visible = true; lblInstalledVersionLabel.Visible = true; btnCheckForUpdate.Visible = true; if (e.Cancelled) { return; } if (e.Error != null) { throw e.Error; } if (_appUpdate.IsUpdateAvailable()) { lblStatus.Text = Language.strUpdateAvailable; lblStatus.ForeColor = Color.OrangeRed; pnlUpdate.Visible = true; var updateInfo = _appUpdate.CurrentUpdateInfo; lblLatestVersion.Text = updateInfo.Version.ToString(); lblLatestVersionLabel.Visible = true; lblLatestVersion.Visible = true; if (updateInfo.ImageAddress == null || string.IsNullOrEmpty(updateInfo.ImageAddress.ToString())) { pbUpdateImage.Visible = false; } else { pbUpdateImage.ImageLocation = updateInfo.ImageAddress.ToString(); pbUpdateImage.Tag = updateInfo.ImageLinkAddress; pbUpdateImage.Visible = true; } _appUpdate.GetChangeLogCompletedEvent += GetChangeLogCompleted; _appUpdate.GetChangeLogAsync(); btnDownload.Focus(); } else { lblStatus.Text = Language.strNoUpdateAvailable; lblStatus.ForeColor = Color.ForestGreen; if (_appUpdate.CurrentUpdateInfo != null) { var updateInfo = _appUpdate.CurrentUpdateInfo; if (updateInfo.IsValid && updateInfo.Version != null) { lblLatestVersion.Text = updateInfo.Version.ToString(); lblLatestVersionLabel.Visible = true; lblLatestVersion.Visible = true; } } } } catch (Exception ex) { lblStatus.Text = Language.strUpdateCheckFailedLabel; lblStatus.ForeColor = Color.OrangeRed; Runtime.MessageCollector.AddExceptionMessage(Language.strUpdateCheckCompleteFailed, ex); } }
/// <summary> /// Create a new form instance. /// </summary> public FormDownload() { InitializeComponent(); this.client.DownloadFileCompleted += this.OnDownloadCompleted; this.client.DownloadProgressChanged += this.OnDownloadProgressChanged; this.delegateProgressChanged = new DownloadProgressChangedEventHandler(this.OnDownloadProgressChanged); this.delegateDownloadCompleted = new AsyncCompletedEventHandler(this.OnDownloadCompleted); this.delegateDownloadError = new WaitCallback(this.DownloadError); this.formatting.SetFont(this); }
public void Download(DownloadProgressChangedEventHandler progressHandler = null, AsyncCompletedEventHandler completedHandler = null) { IsDownloaded = false; if (!Directory.Exists(BasePath)) { try { Directory.CreateDirectory(BasePath); } catch (Exception e) { Console.WriteLine(e); MessageBox.Show(Strings.CantCreateDLDir, Strings.Error, MessageBoxButton.OK, MessageBoxImage.Error); } } using (var wc = new WebClient()) { if (progressHandler != null) wc.DownloadProgressChanged += progressHandler; if (completedHandler != null) wc.DownloadFileCompleted += completedHandler; wc.DownloadFileAsync(new Uri(Properties.Resources.RootAddress + Filename), BasePath + Filename); } }
/* Downloads latest release. * Throws UpdaterException if error occurs. */ public static void Download(AsyncCompletedEventHandler completedHandler = null, DownloadProgressChangedEventHandler progressHandler = null) { if (Latest != null) { if (Latest.IsDownloaded || Latest.IsDownloading) throw new UpdaterException(L10n.Message("Download completed or still in progress")); Latest.Download(completedHandler, progressHandler); } }
/* Downloads release. * Throws UpdaterException if error occurs. */ public void Download(AsyncCompletedEventHandler completedHandler, DownloadProgressChangedEventHandler progressHandler) { if (Client != null) throw new UpdaterException(L10n.Message("Download already in progress")); if (DownloadFile != null) throw new UpdaterException(L10n.Message("Download already completed")); try { // Initialize web client. Client = new UpdaterWebClient(); Client.DownloadFileCompleted += new AsyncCompletedEventHandler(DownloadCompleted); if (completedHandler != null) Client.DownloadFileCompleted += new AsyncCompletedEventHandler(completedHandler); if (progressHandler != null) Client.DownloadProgressChanged += new DownloadProgressChangedEventHandler(progressHandler); // Create download file. DownloadFile = Path.Combine(Path.GetTempPath(), PackageFileName); // Start download. Client.DownloadFileAsync(URI, DownloadFile); } catch (Exception e) { Dispose(); throw new UpdaterException(e.Message, e); } }
public void Download(string dataPath, AsyncCompletedEventHandler callback) { try { using(WebClient client = new WebClient()) { FileInfo dest = new FileInfo(Path.Combine(dataPath, "Updates", this.Latest.FileName)); if(!dest.Directory.Exists) { dest.Directory.Create(); } client.DownloadFileCompleted += delegate(object sender, AsyncCompletedEventArgs e) { if(!e.Cancelled && (e.Error == null)) { this.Unzip(dest.FullName); callback(sender, e); } }; client.DownloadFileAsync(new Uri(this.Latest.FileUrl), dest.FullName); } } catch(WebException exception) { if(this.Error != null) { this.Error(this, new UnhandledExceptionEventArgs(exception, false)); } this.Status = UpdateStatus.Problem; } }
public abstract void Download(DownloadProgressChangedEventHandler progressHandler = null, AsyncCompletedEventHandler completedHandler = null);
public string DownloadEvent(ICamEvent camEvent, AsyncCompletedEventHandler fileDownloadCompleted, DownloadProgressChangedEventHandler progressChanged) { return _connector.DownloadEvent(camEvent, fileDownloadCompleted, progressChanged); }
private void CalculateFolderSize(object value) { Stack<IVirtualFolder> stack = new Stack<IVirtualFolder>(); stack.Push(this.FOwner); Exception error = null; Stopwatch stopwatch = new Stopwatch(); stopwatch.Start(); try { while (stack.Count > 0) { using (IVirtualFolder folder = stack.Pop()) { foreach (IVirtualItem item in folder.GetContent()) { if (item is IVirtualFolder) { stack.Push((IVirtualFolder) item); } else { object obj2 = item[3]; if (obj2 != null) { this.Size += (long) obj2; } obj2 = item[5]; if (obj2 != null) { this.CompressedSize += Convert.ToInt64(obj2); } if ((this.FOwnerParent != null) && (stopwatch.ElapsedMilliseconds >= 500L)) { stopwatch.Reset(); this.FOwnerParent.RaiseChanged(WatcherChangeTypes.Changed, this.FOwner); stopwatch.Start(); } } } } } } catch (Exception exception2) { error = exception2; } finally { stopwatch.Stop(); if (this.FOwnerParent != null) { this.FOwnerParent.RaiseChanged(WatcherChangeTypes.Changed, this.FOwner); } this.FOwner = null; this.FOwnerParent = null; if (this.FCompleted != null) { this.FCompleted(this, new AsyncCompletedEventArgs(error, false, null)); this.FCompleted = null; } } }
/// <summary> /// Download a file from the internet and place it in the local documents directory /// </summary> /// <param name="_filename">The name of the file to download</param> private async Task _LoadFile(string _filename, DownloadProgressChangedEventHandler progress, AsyncCompletedEventHandler finished) { var wc = new WebClient(); wc.DownloadProgressChanged += progress; wc.DownloadFileCompleted += finished; try { _downloading = _files2fetch.Count.ToString() + ": " + _filename + "()"; await wc.DownloadFileTaskAsync("http://casim.hhu.de/Crawler/" + _filename, ".\\Content\\" + _filename); } catch { finished(null, null); } }
private void GetChangeLogCompleted(object sender, AsyncCompletedEventArgs e) { if (InvokeRequired) { var myDelegate = new AsyncCompletedEventHandler(GetChangeLogCompleted); Invoke(myDelegate, sender, e); return; } try { _appUpdate.GetChangeLogCompletedEvent -= GetChangeLogCompleted; if (e.Cancelled) return; if (e.Error != null) throw e.Error; txtChangeLog.Text = _appUpdate.ChangeLog.Replace("\n", Environment.NewLine); } catch (Exception ex) { Runtime.MessageCollector.AddExceptionMessage(Language.strUpdateGetChangeLogFailed, ex); } }
public static int DownloadSong(SongInformation inf, AsyncCompletedEventHandler handler) { if (inf == null || inf.fileName == "" || inf.path == "" || inf.file == "") return -1; if (!Directory.Exists(inf.path)) { Directory.CreateDirectory(inf.path); } if (File.Exists(inf.path + "\\" + inf.file)) return 0; WebClient webClient = new WebClient(); webClient.DownloadFileAsync(new Uri(inf.fileName), inf.path + "\\" + inf.file); webClient.DownloadFileCompleted += handler; return 1; }
// Does not work yet.. does not return at the moment, not sure why, specs seem to be correctly implemented //public async Task<string> GetEventStream(CamEvent camEvent) //{ // var httpRequest = new HttpRequest(); // httpRequest.Parameters.Add("api", "SYNO.SurveillanceStation.Streaming"); // httpRequest.Parameters.Add("version", "1"); // httpRequest.Parameters.Add("_sid", _sessionId); // httpRequest.Parameters.Add("eventId", camEvent.Id.ToString()); // httpRequest.Parameters.Add("method", "EventStream"); // httpRequest.Headers.Add("User-Agent", "SynoCam"); // httpRequest.Headers.Add("Range", "bytes=0-9999999"); // httpRequest.Headers.Add("Icy-MetaData", "1"); // var eventData = await GetDataFromUrl(httpRequest, _url + "streaming.cgi"); // return ""; //} public string DownloadEvent(ICamEvent camEvent, AsyncCompletedEventHandler fileDownloadCompleted, DownloadProgressChangedEventHandler progressChanged) { string tempPath = Path.GetTempPath(); string nameWithoutPrefix = camEvent.Name.Substring(camEvent.Name.LastIndexOf("/", StringComparison.Ordinal) + 1); string url = string.Format("{0}entry.cgi/{1}?api=SYNO.SurveillanceStation.Event&method=Download&version=4&eventId={2}&_sid={3}", _url, nameWithoutPrefix, camEvent.Id, _sessionId); string tempFile = Path.Combine(tempPath, nameWithoutPrefix); using (var downloadClient = new WebClient()) { downloadClient.DownloadFileCompleted += fileDownloadCompleted; downloadClient.DownloadFileCompleted += (sender, args) => _deleteFilesBeforeExit.Add(tempFile); downloadClient.DownloadProgressChanged += progressChanged; downloadClient.DownloadFileAsync(new Uri(url), tempFile); } return tempFile; }
public void DownloadInstallerAsync(DownloadProgressChangedEventHandler progress, AsyncCompletedEventHandler completed) { var client = new WebClient(); if(progress != null){ client.DownloadProgressChanged += progress; } if(completed != null){ client.DownloadFileCompleted += completed; } string file = Path.GetTempPath() + Path.GetFileName(this.InstallerUri.AbsolutePath); client.DownloadFileAsync(this.InstallerUri, file, file); }
public string DownloadEvent(ICamEvent camEvent, AsyncCompletedEventHandler fileDownloadCompleted, DownloadProgressChangedEventHandler progressChanged) { throw new NotImplementedException(); }