protected virtual void OnLoadCompleted(AsyncCompletedEventArgs e)
 {
     if (LoadCompleted != null)
     {
         LoadCompleted(this, e);
     }
 }

 public DecisionArgs Build(AsyncCompletedEventArgs eventArgs)
 {
     return new DecisionArgs
     {
         EventArgsOfWebClient = eventArgs
     };
 }

 void _webClient_DownloadFileCompleted(object sender, AsyncCompletedEventArgs e)
 {
     Audio audio = e.UserState as Audio;
     string filePath = String.Format("{0}.mp3", audio.ToString());
     TagLib.File tagFile = TagLib.File.Create(filePath);
     string artistName = tagFile.Tag.FirstAlbumArtist == null ? "Unknown artist" : tagFile.Tag.FirstAlbumArtist;
     string albumName = tagFile.Tag.Album == null ? "Unknown album" : tagFile.Tag.Album;
     string title = tagFile.Tag.Title == null ? "Unknown title" : tagFile.Tag.Title;
     var artist = _artists.FirstOrDefault(g => g.Name.ToLower() == artistName.ToLower());
     if (artist == null)
     {
         artist = new Artist(artistName);
         _artists.Add(artist);
     }
     var album = artist.Albums.FirstOrDefault(g => g.Name.ToLower() == albumName.ToLower());
     if (album == null)
     {
         album = new Album(albumName);
         artist.Albums.Add(album);
     }
     var song = album.Songs.FirstOrDefault(g => g.Name.ToLower() == title.ToLower());
     if (song == null)
     {
         song = new Song(title, filePath);
         album.Songs.Add(song);
     }
 }

 private void ClientDownloadFileCompleted(object sender, AsyncCompletedEventArgs e)
 {
     m_downloaded = true;
     if (e.Cancelled)
         m_error = true;
     Program.Frm.SetProgress(100);
 }

 protected bool HasError(AsyncCompletedEventArgs args)
 {
     var hasError = args.Error != null;
     if (hasError)
         OnNewSystemMessage(args.Error.Message);
     return hasError;
 }

 /// MONO completely lacks SmtpClient.SendAsync, so this is a copy -----------------------------------------------------------------------------
 /// <summary>
 /// 
 /// </summary>
 /// <param name="tcs"></param>
 /// <param name="e"></param>
 /// <param name="handler"></param>
 /// <param name="client"></param>
 static void HandleCompletion(TaskCompletionSource<object> tcs, AsyncCompletedEventArgs e, SendCompletedEventHandler handler, SmtpClient client)
 {
     if (e.UserState == tcs)
     {
         try
         {
             client.SendCompleted -= handler;
         }
         finally
         {
             if (e.Error != null)
             {
                 tcs.TrySetException(e.Error);
             }
             else if (!e.Cancelled)
             {
                 tcs.TrySetResult(null);
             }
             else
             {
                 tcs.TrySetCanceled();
             }
         }
     }
 }

 private void client_DownloadFileCompleted(object sender, AsyncCompletedEventArgs e)
 {
     lbl_status.Text = "Status: Completed";
     Thread.Sleep(500);
     Process.Start("R2_Compiler_conf_gui.exe");
     Application.Exit();
 }

        private void client_DownloadFileCompleted(object sender, AsyncCompletedEventArgs e)
        {
            string rootDir = Path.GetDirectoryName(this.FilePath);
            string unzipFolder = Path.Combine(rootDir, this.NewVersion);
            if (Directory.Exists(unzipFolder))
            {
                Directory.Delete(unzipFolder, true);
            }
            Directory.CreateDirectory(unzipFolder);
            ZipHelp.UnZip(this.FilePath, unzipFolder);

            string sourceFolder = "";
            var files = Directory.EnumerateFiles(unzipFolder, Config.MainExe, SearchOption.AllDirectories);
            if (files != null && files.Count() == 1)
            {
                var targetFileName = files.FirstOrDefault();
                sourceFolder = Path.GetDirectoryName(targetFileName);
            }

            string targetDir = Environment.CurrentDirectory;
            foreach (var process in Process.GetProcessesByName("CKGen"))
            {
                process.Kill();
            }

            RenameAllFile(targetDir);
            //copy 
            ProcessXcopy(sourceFolder, targetDir);

            Process.Start(Path.Combine(Environment.CurrentDirectory, Config.MainExe));

            this.Close();
        }

		public void BeginDownload(RemoteFileInfo fileInfo, string destPath)
		{
			try
			{
				var localFileInfo = new FileInfo(destPath);
				if (localFileInfo.Exists)
				{
					if (Sha1VerifyFile(destPath, fileInfo.Sha1Hash))
					{
						var newEvt = new AsyncCompletedEventArgs(null, false, null);
						DownloadFileCompleted(this, newEvt);
						return; //already have the file with correct contents on disk
					}
				}
			}
			catch (Exception ex)
			{
				var newEvt = new AsyncCompletedEventArgs(ex, false, null);
				DownloadFileCompleted(this, newEvt);
				return; //something failed when trying to hash file
			}

			if (_wc != null)
			{
				_wc.CancelAsync();
				_wc.Dispose();
				_wc = null;
			}

			_wc = new CustomWebClient(Timeout);
			_wc.DownloadProgressChanged += (sender, evt) => { DownloadProgressChanged(sender, evt); };
			_wc.DownloadFileCompleted += (sender, evt) =>
			{
				using (var wc = (WebClient) sender)
				{
					if (evt.Cancelled || evt.Error != null)
					{
						DownloadFileCompleted(sender, evt);
						return;
					}

					try
					{
						if (!Sha1VerifyFile(destPath, fileInfo.Sha1Hash))
							throw new Exception("Hash mismatch after download");
					}
					catch (Exception ex)
					{
						var newEvt = new AsyncCompletedEventArgs(ex, false, evt.UserState);
						DownloadFileCompleted(sender, newEvt);
						return;
					}

					DownloadFileCompleted(sender, evt);
				}
				_wc = null;
			};

			_wc.DownloadFileAsync(new Uri(fileInfo.Url), destPath);
		}

        /// <summary>
        /// Callback by the web client class when the download finish (completed or cancelled)
        /// </summary>
        void ClientDownloadFileCompleted(object sender, AsyncCompletedEventArgs e)
        {
            Thread.Sleep(1500);     // A short pause for a better visual flow

            inProgress.Set();
            isCompleted = !e.Cancelled;
        }

 void wc_DownloadFileCompleted(object sender, AsyncCompletedEventArgs e)
 {
   if (e.Error != null || e.Cancelled)
   {
     Trace.TraceError("{0} failed {1}", Name, e.Error);
     Finish(false);
   }
   else
   {
     Trace.TraceInformation("{0} Completed - {1}", Name, Utils.PrintByteLength(Length));
     try
     {
       File.Delete(targetFilePath);
     }
     catch {}
     try
     {
       File.Move(tempFilePath, targetFilePath);
     }
     catch
     {
       Trace.TraceError("Error moving file from {0} to {0}", tempFilePath, targetFilePath);
       Finish(false);
       return;
     }
     Finish(true);
   }
 }

 private void Completed2(object sender, AsyncCompletedEventArgs e)
 {
     File.Copy(savePath + "/cs_bg_champions.png", savePath + "/login.swf", true);
     //MessageBox.Show("Download completed!");
     this.Hide();
     MessageBox.Show("Download completed." + Environment.NewLine + Environment.NewLine + "To enable music, you may need to click on \"Disable Menu Animations\".", "Info", MessageBoxButtons.OK, MessageBoxIcon.Information);
 }

 void wc_DownloadFileCompleted(object sender, AsyncCompletedEventArgs e)
 {
     if (e.Error != null&&!e.Cancelled)
     {
         //下载出错
         label2.Text = e.Error.Message;
         CancleBtn.Text = "关闭";
         //File.Delete(Application.StartupPath + "/" + DownloadInfo.FileDirectory + "/" + DownloadInfo.FileName);
     }
     else
     {
         if (!e.Cancelled)
         {
             label2.Text = "下载完成";
             CancleBtn.Text = "关闭";
             Process proc = new Process();
             proc.StartInfo.FileName = Application.StartupPath + "/" + DownloadInfo.FileDirectory + "/" + DownloadInfo.FileName;
             proc.StartInfo.Arguments = "";
             proc.Start();
             if (CloseCheckBox.Checked)
             {
                 this.Close();
             }
         }
         else
         {
             //用户取消了下载
             File.Delete(Application.StartupPath + "/" + DownloadInfo.FileDirectory + "/" + DownloadInfo.FileName);
             this.Close();
         }
     }
 }

 private void Completed(object sender, AsyncCompletedEventArgs e)
 {
     progressBar.Visibility = System.Windows.Visibility.Hidden;
     Feedback.Text = "Download completed";
     Feedback.Visibility = System.Windows.Visibility.Visible;
     Process.Start(downloadedFile);
 }

        public void DownloadFileAsync_should_be_callable_indirectly()
        {
            using (new IndirectionsContext())
            {
                // Arrange
                var called = false;
                var notCalled = true;
                var handler = default(AsyncCompletedEventHandler);
                handler = (sender, e) => called = true;
                PULWebClient.AddDownloadFileCompletedAsyncCompletedEventHandler().Body = (@this, value) => handler += value;
                PULWebClient.RemoveDownloadFileCompletedAsyncCompletedEventHandler().Body = (@this, value) => handler -= value;
                PULWebClient.DownloadFileAsyncUri().Body = (@this, address) =>
                {
                    var e = new AsyncCompletedEventArgs(null, false, null);
                    handler(@this, e);
                };

                
                // Act
                var client = new ULWebClient();
                client.DownloadFileAsync(new Uri("http://google.co.jp/"));
                client.DownloadFileCompleted += (sender, e) => notCalled = false;

                
                // Assert
                Assert.IsTrue(called);
                Assert.IsTrue(notCalled);
            }
        }

 //Call completed to run DLR, completed2 for non-DLR pkgs.
 public static void Completed(object sender, AsyncCompletedEventArgs e)
 {
     MessageBox.Show("Download completed!", "File complete");//Tell user
     progressBar.Value = 0;// set back to zero so we know it finished, some ppl are dumb
     table.dlrfinished = true;//dl complete?
     Process.Start((Form1.FilePath1) + (Form1.FilePath2));
 }

        void client_DownloadFileCompleted(object sender, AsyncCompletedEventArgs e)
        {
            // install updates
            this.BeginInvoke((MethodInvoker)delegate {
                // Start installer & wait for exit
                statusLabel.Text = "Installing update...";
                progressBar1.Value = 0;
                progressBar1.Style = ProgressBarStyle.Marquee;
                ProcessStartInfo procStart = new ProcessStartInfo("msiexec.exe");
                procStart.Arguments = "/i \""+ InstallerPath + "\" /qr";
                Process p = Process.Start(procStart);
                p.WaitForExit();

                // run installed application & close updater
                statusLabel.Text = "Installation complete!";
                progressBar1.Style = ProgressBarStyle.Blocks;
                progressBar1.Value = 100;

                RegistryKey key = Registry.CurrentUser.OpenSubKey("SOFTWARE\\Stijn Raeymaekers\\Weather Wallpaper");
                string installedExe = key.GetValue("installDirectory") + "WeatherWallpaper.exe";
                Process.Start(installedExe);

                Thread.Sleep(1500);
                Environment.Exit(0);
            });
        }

        private static void client_DownloadFileCompleted(object sender, AsyncCompletedEventArgs e)
        {
            ZipFile.ExtractToDirectory(Path.Combine(Logic.Logic.InstallDirectory, "temp", "LegendaryClient.zip"),
                Logic.Logic.InstallDirectory);

            Logic.Logic.Installed = true;
            Logic.Logic.SwichPage<Finished>();

            Directory.Delete(Path.Combine(Logic.Logic.InstallDirectory, "temp"), true);

            string x = Path.Combine(Logic.Logic.InstallDirectory, "Client", "LC", "Version.Version");
            string l = Path.Combine(Logic.Logic.InstallDirectory, "Client", "LC");
            if (!Directory.Exists(l))
                Directory.CreateDirectory(l);

            if (File.Exists(x))
                return;

            //Write the version to the file
            FileStream y = File.Create(x);
            y.Close();

            var writer = new StreamWriter(x);
            writer.Write(Logic.Logic.Version);
            writer.Close();
        }

        private static void smtpClient_SendCompleted(object sender, AsyncCompletedEventArgs e) {
            // Get the message we sent
            MailMessage mailMessage = (MailMessage)e.UserState;
            MainWindow mainWindow = (MainWindow)Application.Current.MainWindow;

            if (e.Cancelled) {
                // prompt user with "send cancelled" message 
                mainWindow.showDialogue("Send Error", "Send Cancelled!");
            }
            if (e.Error != null) {
                // prompt user with error message 
                mainWindow.showDialogue("Send Error", e.Error.Message);
                System.Console.WriteLine(e.Error.Message);
            }
            else {
                // prompt user with message sent!
                // as we have the message object we can also display who the message
                // was sent to etc 
                mainWindow.showDialogue("Send Success", "Message Send Successfully!");
            }

            // finally dispose of the message
            if (mailMessage != null) {
                mailMessage.Dispose();
            }
                
        }

        public void client_DownloadFileCompleted(object sender, AsyncCompletedEventArgs e)
        {
            OnExtracting();

            try
            {
                using (ZipFile file = ZipFile.Read(_updateFileName))
                {
                    foreach (ZipEntry entry in file)
                    {
                        // TODO
                        //_dialog.Line3 = entry.FileName;
                        entry.Extract(this.Path, ExtractExistingFileAction.OverwriteSilently);
                        _extractedFiles.Add(entry.FileName);
                    }

                    // TODO
                    //_dialog.Line2 = "Verifying signatures";

                    foreach (ZipEntry entry in file)
                    {
                        if (!entry.FileName.EndsWith(".dll") && !entry.FileName.EndsWith(".exe"))
                            continue;

                        // TODO
                        //_dialog.Line3 = entry.FileName;

                        try
                        {
                            string status;
                            if (!VerifyCertificate(X509Certificate.CreateFromSignedFile(entry.FileName).GetRawCertData(), out status))
                            {
                                OnErrorOccurred(entry.FileName + " does not have a valid signature!\n\n" + status);
                                CleanUp(true);
                                break;
                            }
                        }
                        catch (CryptographicException ex)
                        {

                            OnErrorOccurred(string.Format("A cryptographic exception occurred while trying to verify the signature of: {0}\n{1}\n\nThis probably means that this file doesn't have a valid signature!", entry.FileName, ex.Message));
                            CleanUp(true);
                            break;
                        }
                        catch (Exception ex)
                        {
                            OnErrorOccurred(string.Format("An exception occurred while trying to verify the signature of: {0}\n{1}", entry.FileName, ex.Message));
                            CleanUp(true);
                            break;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                OnErrorOccurred("Could not extract update:\n" + ex.Message);
            }

            OnFinish();
        }