public static void ParseTopPerson(string html, Action<List<Person>> finished)
 {
     BackgroundWorker bw = new BackgroundWorker();
     bw.DoWork += new DoWorkEventHandler((sender, e) =>
     {
         List<Person> TopPerson = new List<Person>();
         HtmlDocument hDoc = new HtmlDocument();
         hDoc.LoadHtml(html);
         var tableRows = hDoc.DocumentNode.SelectNodes(Constants.Instance.XPATH_GAME_TOP_RESULT);
         foreach (var node in tableRows)
         {
             var results = ChildElementsInTableRow(node);
             if (results.Count == Constants.Instance.COUNT_GAME_TOP_RESULT_COLUMNS)
             {
                 var person = TopPersonFromStrings(results);
                 if (person.Total != 0)
                 {
                     TopPerson.Add(person);
                 }
             }
         }
         finished(TopPerson);
     });
     bw.RunWorkerAsync();
 }

        private IEnumerable<XElement> AddDirectoryAsync(DirectoryInfo dir, string collectionId, ref int count, int fnumber,
            BackgroundWorker worker)
        {
            List<XElement> addedElements = new List<XElement>();
            // добавление коллекции
            string subCollectionId;
            List<XElement> ae = this.cass.AddCollection(dir.Name, collectionId, out subCollectionId).ToList();
            if (ae.Count > 0) addedElements.AddRange(ae);

            count++;
            foreach (FileInfo f in dir.GetFiles())
            {
                if (worker.CancellationPending) break;
                if (f.Name != "Thumbs.db")
                    addedElements.AddRange(this.cass.AddFile(f, subCollectionId));
                count++;
                worker.ReportProgress(100 * count / fnumber);
            }
            foreach (DirectoryInfo d in dir.GetDirectories())
            {
                if (worker.CancellationPending) break;
                addedElements.AddRange(AddDirectoryAsync(d, subCollectionId, ref count, fnumber, worker));
            }
            return addedElements;
        }

 public static void ParseRecommends(string html, Action<List<Recommend>> finished)
 {
     BackgroundWorker bw = new BackgroundWorker();
     bw.DoWork += new DoWorkEventHandler((sender, e) =>
     {
         List<Recommend> allRecommends = new List<Recommend>();
         HtmlDocument hDoc = new HtmlDocument();
         hDoc.LoadHtml(html);
         var tableRows = hDoc.DocumentNode.SelectNodes(Constants.Instance.XPATH_GAME_SHOW_RESULT);
         foreach (var node in tableRows)
         {
             var results = ChildElementsInTableRow(node);
             if (results.Count == Constants.Instance.COUNT_GAME_SHOW_RESULT_COLUMNS)
             {
                 var rec = RecommendFromStrings(results);
                 if (IsValidRecommend(rec))
                 {
                     allRecommends.Add(rec);
                 }
             }
         }
         finished(allRecommends);
     });
     bw.RunWorkerAsync();
 }

 public ScannerProgress(string folder, BackgroundWorker worker)
 {
     this.worker = worker;
     InitializeComponent();
     UpdateFolder(folder);
     UpdateAction("");
 }

        public CPromoCashableDetails(string RouteNumber, DateTime StartDate, DateTime EndDate,int UserNo)
        {
            InitializeComponent();
            _worker = new BackgroundWorker();
            _worker.WorkerReportsProgress = true;
            _worker.WorkerSupportsCancellation = true;

            CurrencySymbol = CurrencySymbol.GetCurrencySymbol();
            this.RouteNumber = RouteNumber;
            this.StartDate = StartDate;
            this.EndDate = EndDate;
            this.UserNo = UserNo;

            // For resizing columns automatically.
            GridView gv = lvPromoCashable.View as GridView;
            if (gv != null)
            {
                foreach (GridViewColumn gvc in gv.Columns)
                {
                    gvc.Width = gvc.ActualWidth;
                    if (gvc.Width == 0.0 || gvc.Width == 0)
                        gvc.Width = 0;
                    else
                        gvc.Width = Double.NaN;
                }
            }        
        }

 private static void UpdateCheck()
 {
     Game.PrintChat("<font color='#33FFFF'> .: Orianna by trelli loaded :.");
     var bgw = new BackgroundWorker();
     bgw.DoWork += bgw_DoWork;
     bgw.RunWorkerAsync();
 }

        /// <summary>
        /// Lance une tache dans un background worker.
        /// </summary>
        /// <param name="taskFunc">Tache à exécuter.</param>
        /// <param name="completionAction">Action à réaliser après l'exécution. Recoit l'exception si une exception a eu lieu.</param>
        public static void Start(Action taskFunc, Action<Exception> completionAction)
        {
            if (taskFunc == null)
            {
                throw new ArgumentNullException("taskFunc");
            }

            var backgroundWorker = new BackgroundWorker();

            backgroundWorker.DoWork += new DoWorkEventHandler(
                delegate
                {
                    taskFunc();
                });

            backgroundWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(
                delegate(object sender, RunWorkerCompletedEventArgs e)
                {
                    if (completionAction != null)
                    {
                        completionAction(e.Error);
                    }
                });

            backgroundWorker.RunWorkerAsync();
        }

        public Form1()
        {
            InitializeComponent();
            util = new Utility();
            mainJobList = new BindingList<IndeedDetails>();
            filtered = new List<IndeedDetails>();
            sortKeeper = new GridSortBy();
            //worker stuff
            worker = new BackgroundWorker();

            worker.DoWork += BackgroundWorkerDoWork;
            worker.RunWorkerCompleted +=
               BackgroundWorkerRunWorkerCompleted;

            string file_name = @"C:\Users\apersinger\Documents\Misc\jsonjobs.txt";
            string file_contents = util.OpenFile(file_name);
            if(file_contents.Length > 0) {
                data = util.DeserializeString(file_contents);
                mainJobList = new BindingList<IndeedDetails>(data);
                dataGridView1.DataSource = mainJobList;
            }

            txtURL.Text = "www.indeed.com";
            txtLocation.Text = "california";
            txtJobTitle.Text = "software";

            btnFilterResults.Enabled = false;
        }

    public PluginUpdaterForm(PluginManager pluginManager)
      : base() {
      InitializeComponent();
      Text = "HeuristicLab Plugin Manager " + AssemblyHelpers.GetFileVersion(GetType().Assembly);
      pluginManager.PluginLoaded += pluginManager_PluginLoaded;
      pluginManager.PluginUnloaded += pluginManager_PluginUnloaded;
      pluginManager.Initializing += pluginManager_Initializing;
      pluginManager.Initialized += pluginManager_Initialized;

      pluginDir = Application.StartupPath;

      installationManager = new InstallationManager(pluginDir);
      installationManager.PluginInstalled += new EventHandler<PluginInfrastructureEventArgs>(installationManager_PluginInstalled);
      installationManager.PluginRemoved += new EventHandler<PluginInfrastructureEventArgs>(installationManager_PluginRemoved);
      installationManager.PluginUpdated += new EventHandler<PluginInfrastructureEventArgs>(installationManager_PluginUpdated);
      installationManager.PreInstallPlugin += new EventHandler<PluginInfrastructureCancelEventArgs>(installationManager_PreInstallPlugin);
      installationManager.PreRemovePlugin += new EventHandler<PluginInfrastructureCancelEventArgs>(installationManager_PreRemovePlugin);
      installationManager.PreUpdatePlugin += new EventHandler<PluginInfrastructureCancelEventArgs>(installationManager_PreUpdatePlugin);

      this.pluginManager = pluginManager;

      updatePluginsBackgroundWorker = new BackgroundWorker();
      updatePluginsBackgroundWorker.DoWork += new DoWorkEventHandler(updatePluginsBackgroundWorker_DoWork);
      updatePluginsBackgroundWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(updatePluginsBackgroundWorker_RunWorkerCompleted);
    }

        public bool dooptimization()
        {
            initialcount = points.Count;
            currentpoint = 0;
            finishedthreads = 0;
            bws = new List<BackgroundWorker>();
            for(int i=0;i<100;i++)
            {
                bws.Add(new BackgroundWorker());
                            bws[i] = new BackgroundWorker
                {
                    WorkerReportsProgress = true,
                    WorkerSupportsCancellation = true
                };
                bws[i].DoWork += bw_DoWork;

                bws[i].RunWorkerCompleted += bw_RunWorkerCompleted;
                bws[i].RunWorkerAsync();//pass id???, what else?

            }
            while (finishedthreads!=100)
            {

            }
                return true;
        }

        private void b_open_Click(object sender_, RoutedEventArgs e_)
        {
            p_progress.Visibility = Visibility.Visible;
            p_label.Visibility = Visibility.Visible;

            bw_LoadFile = new BackgroundWorker();
            bw_LoadFile.DoWork += (sender, e) =>
            {
                LCIO.OpenFile(bw_LoadFile);
            };
            bw_LoadFile.ProgressChanged += (sender, e) =>
            {
                p_label.Content = e.UserState;
            };
            bw_LoadFile.RunWorkerCompleted += (sender, e) =>
            {
                if (e.Error != null)
                {
                    new TextMessage("Ошибка", e.Error.Message).ShowDialog();
                }
                p_progress.Visibility = Visibility.Hidden;
                p_label.Visibility = Visibility.Hidden;
                FLYOUT_OpenFile.IsOpen = false;
                UpdateList();
            };
            bw_LoadFile.WorkerReportsProgress = true;
            bw_LoadFile.RunWorkerAsync();
        }

        public Lobby(Menu parent)
        {
            InitializeComponent();

            ImageBrush myBrush = new ImageBrush();
            myBrush.ImageSource = new BitmapImage(new Uri(".\\Resources\\icon_backarrow.png", UriKind.Relative));
            bekk.Background = myBrush;

            ImageBrush myBrush2 = new ImageBrush();
            myBrush2.ImageSource = new BitmapImage(new Uri(".\\Resources\\icon_closebutton.png", UriKind.Relative));
            klóz.Background = myBrush2;

            this.parent = parent;

            chatbox.Items.Clear();

            refreshworker = new BackgroundWorker();
            refreshworker.WorkerSupportsCancellation = true;
            refreshworker.WorkerReportsProgress = true;
            refreshworker.DoWork += refresh;
            refreshworker.ProgressChanged += refreshUI;

            activityworker = new BackgroundWorker();
            activityworker.WorkerSupportsCancellation = true;
            activityworker.DoWork += wait;
            activityworker.RunWorkerCompleted += doActivity;
        }

        public AtmosphereControl( )
        {
            InitializeComponent( );

            //	Populate texture resolution combo boxes
            for ( int i = 4; i <= 1024; i *= 2 )
            {
                resolutionComboBox.Items.Add( i );
            }
            resolutionComboBox.SelectedItem = m_AtmosphereBuildParameters.HeightSamples;

            m_AtmosphereBuilder = new AtmosphereBuilder( );

            mH0UpDown.Value = ( decimal )m_AtmosphereModel.MieDensityScaleHeightFraction;
            rH0UpDown.Value = ( decimal )m_AtmosphereModel.RayleighDensityScaleHeightFraction;
            //	TODO: AP: Remove bodges
            inscatterDistanceFudgeUpDown.Value = ( decimal )m_AtmosphereModel.InscatterDistanceFudgeFactor;
            outscatterDistanceFudgeUpDown.Value = ( decimal )m_AtmosphereModel.OutscatterDistanceFudgeFactor;
            outscatterFudgeUpDown.Value = ( decimal )m_AtmosphereModel.OutscatterFudgeFactor;
            mieFudgeUpDown.Value = ( decimal )m_AtmosphereModel.MieFudgeFactor;
            rayleighFudgeUpDown.Value = ( decimal )m_AtmosphereModel.RayleighFudgeFactor;

            m_Worker = new BackgroundWorker( );
            m_Worker.WorkerReportsProgress = true;
            m_Worker.WorkerSupportsCancellation = true;
            m_Worker.DoWork += BuildWorkItem;
            m_Worker.RunWorkerCompleted += WorkItemComplete;
            m_Worker.ProgressChanged += BuildProgressChanged;
        }

 private void button1_Click(object sender, EventArgs e)
 {
     BackgroundWorker worker = new BackgroundWorker();
     DataLocation loc = (DataLocation)ComboBoxSearchLocation.SelectedIndex;
     worker.DoWork += (s, args) =>
     {
         try
         {
             Data.Letter[] LettersControl = null;
             DateType _dType = DateType.All;
             if (!CalendarAllCheckBox.Checked)
                 _dType = (DateType)ComboBoxDate.SelectedIndex + 1;
             LettersControl = DBase.DataBase.GetLetters(TXTNumber.GetValue(), ComboProviders.Text, ComboTypes.Text, TXTFrom.Text, TXTTo.Text, TXTMoney.Text, TXTMoney2.Text, ComboUser.SelectedItem.ToString(), TextInc.Text, _dType, DateFrom.Value, DateTo.Value, loc);
             args.Result = LettersControl;
         }
         catch { args.Result = null; }
     };
     worker.RunWorkerCompleted += (s, args) =>
     {
         if (args.Result == null) return;
         AddLetters(args.Result as Data.Letter[]);
         (this.ParentForm as Form1).WaitDisable();
     };
     (this.ParentForm as Form1).WaitEnable();
     worker.RunWorkerAsync();
 }

        public static void MakeDatZips(object sender, DoWorkEventArgs e)
        {
            _bgw = sender as BackgroundWorker;
            Program.SyncCont = e.Argument as SynchronizationContext;
            if (Program.SyncCont == null)
            {
                _bgw = null;
                return;
            }

            if (!Directory.Exists(_outputdir))
                return;

            if (_treeRow != null)
                FindDats(_treeRow);
            else
            {
                RvGame tGame = new RvGame();
                tGame.DBRead((int)_gameId, true);
                ExtractGame(tGame, _outputdir);
            }
            _bgw.ReportProgress(0, new bgwText("Creating Zips Complete"));
            _bgw = null;
            Program.SyncCont = null;
        }

 public void CreateDictionaryHash()
 {
     var prefixTreeThread = new BackgroundWorker();
     prefixTreeThread.DoWork += ReadPrefixTree;
     prefixTreeThread.RunWorkerCompleted += ReadPrefixTreeComplete;
     prefixTreeThread.RunWorkerAsync();
 }

        private void uiRecoverButton_Click(object sender, EventArgs e)
        {
            if(string.IsNullOrWhiteSpace(path))
            {
                MessageBox.Show("Please select an extracted OSIRT case file", "No case path selected", MessageBoxButtons.OK,MessageBoxIcon.Warning);
                return;
            }

            if (!IsExtractedCase(path))
            {
                MessageBox.Show("This doesn't appear to be an extracted OSIRT case file. Directory is missing case.db file.", "Not extracted OSIRT case", MessageBoxButtons.OK, MessageBoxIcon.Error);
                return;
            }

            FlipUi(true, "Recovering...");
            var backgroundWorker = new BackgroundWorker();
            backgroundWorker.DoWork += delegate
            {
                System.Threading.Thread.Sleep(1000);
                RezipCase(path);
              
            };
            backgroundWorker.RunWorkerCompleted += delegate
            {
                FlipUi(false, "Recover");
            };
            backgroundWorker.RunWorkerAsync();
        }

 /// <summary>
 /// Initialize the manager, should be called in OnNavigatedTo of main page.
 /// </summary>
 public void Initialize()
 {
     socket = new StreamSocket();
     dataReadWorker = new BackgroundWorker();
     dataReadWorker.WorkerSupportsCancellation = true;
     dataReadWorker.DoWork += new DoWorkEventHandler(ReceiveMessages);
 }

 public void _timer_Elapsed(object sender, ElapsedEventArgs e)
 {
     Classes.CustomSnapshotRoot root = null;
     Classes.KeeperAPI keeper = new Classes.KeeperAPI();
     Action workAction = delegate
     {
         BackgroundWorker worker = new BackgroundWorker();
         worker.DoWork += delegate
         {
             root = keeper.getKeeperInfo(guid);
         };
         worker.RunWorkerCompleted += delegate
         {
             try {
                 //image.Source = null;
                 Classes.ScoreboardRenderer render = new Classes.ScoreboardRenderer(this, root.snapshot.mapId, root);
             }catch(Exception ex)
             {
                 Classes.Logger.addLog(ex.ToString(), 1);
             }
             //Update code in here
         };
         worker.RunWorkerAsync();
     };
     Application.Current.Dispatcher.BeginInvoke(DispatcherPriority.Background, workAction);
 }

 //bool toCancelReceive = false;
 /// <summary>
 /// Асинхронно и рекурсивно добавляет набор файлов и директорий в кассету в указанную коллекцию
 /// и возвращает набор добавленных в базу данных XElement-записей - это для синхронизации
 /// </summary>
 /// <param name="filenamesAndCollectionId">К массиву имен файлов и директорий, последним элементом прикреплен (добавлен) идентификатор коллекции, в которую записываются внешние файлы</param>
 /// <param name="worker"></param>
 /// <param name="e"></param>
 /// <returns></returns>
 private IEnumerable<XElement> AddFilesAndDirectoriesAsync(string[] filenamesAndCollectionId,
     BackgroundWorker worker, DoWorkEventArgs e)
 {
     List<XElement> addedElements = new List<XElement>();
     string[] filenames = filenamesAndCollectionId.Take(filenamesAndCollectionId.Length - 1).ToArray();
     string collectionId = filenamesAndCollectionId[filenamesAndCollectionId.Length - 1];
     // правильно посчитаю число вводимых файлов
     int fnumber = 0;
     foreach (string fn in filenames)
     {
         if (File.Exists(fn)) { if (fn != "Thumbs.db") fnumber++; }
         else fnumber += 1 + CountTotalFiles(new DirectoryInfo(fn));
     }
     // а теперь добавлю файлы и директории с
     int count = 0;
     foreach (string fname in filenames)
     {
         if (worker.CancellationPending) break;
         if (File.Exists(fname))
         {
             if (fname != "Thumbs.db")
                 addedElements.AddRange(this.cass.AddFile(new FileInfo(fname), collectionId));
             count++;
             worker.ReportProgress(100 * count / fnumber);
         }
         else if (Directory.Exists(fname))
         {
             //smallImageFullNames.AddRange(this.cass.AddDirectory(new DirectoryInfo(fname), collectionId));
             addedElements.AddRange(AddDirectoryAsync(new DirectoryInfo(fname), collectionId, ref count, fnumber, worker));
         }
     }
     return addedElements;
 }