CancelAsync() public method

public CancelAsync ( ) : void
return void
コード例 #1
1
ファイル: Window4.xaml.cs プロジェクト: Celderon/oxyplot
        public Window4()
        {
            InitializeComponent();
            this.PlotModel = new PlotModel();
            this.PlotModel.Series.Add(new FunctionSeries());
            DataContext = this;
            var worker = new BackgroundWorker { WorkerSupportsCancellation = true };
            double x = 0;
            worker.DoWork += (s, e) =>
            {
                while (!worker.CancellationPending)
                {
                    lock (this.PlotModel.SyncRoot)
                    {
                        this.PlotModel.Title = "Plot updated: " + DateTime.Now;
                        this.PlotModel.Series[0] = new FunctionSeries(Math.Sin, x, x + 4, 0.01);
                    }
                    x += 0.1;
                    PlotModel.InvalidatePlot(true);
                    Thread.Sleep(100);
                }
            };

            worker.RunWorkerAsync();
            this.Closed += (s, e) => worker.CancelAsync();
        }
コード例 #2
0
 /**
  * Method to implement the Search/Abort functionality. Each consecutive press of the button
  * changes the mode of operation of the button.
  * The status bar is used to display the current mode od operation.
  */
 private void searchButton_Click(object sender, EventArgs e)
 {
     if (file == null)
     {
         MessageBox.Show("Please select a file before starting the search", "Error");
     }
     else
     {
         if (button_flag == false)
         {
             listView1.Items.Clear();
             b_worker.RunWorkerAsync();
             searchButton.Text          = "Cancel";
             button_flag                = true;
             toolStripStatusLabel1.Text = "Performing search...";
             clearButton.Enabled        = false;
         }
         else
         {
             b_worker.CancelAsync();
             button_flag                = false;
             searchButton.Text          = "Search";
             toolStripStatusLabel1.Text = "Ready for operation";
             clearButton.Enabled        = true;
             instancesFoundBox.Text     = (listView1.Items.Count).ToString();
         }
     }
 }
コード例 #3
0
 public void OnTimedEvent(object source, ElapsedEventArgs e)
 {
     Searcher.CancelAsync();
     aTimer.Enabled = false;
     aTimer.Stop();
     TabPage.displayError("Connection Timed Out. Please Check your Internet Connection.");
 }
コード例 #4
0
 /// <summary>
 /// 停止发送心跳包.
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="e"></param>
 protected override void Func2(object sender, EventArgs e)
 {
     if (backgroundWorker1.WorkerSupportsCancellation == true)
     {
         // Cancel the asynchronous operation.
         backgroundWorker1.CancelAsync();
     }
 }
コード例 #5
0
 private void formClosingCallback(object sender, FormClosingEventArgs e)
 {
     if (backgroundWorker1.WorkerSupportsCancellation == true)
     {
         // Cancel the asynchronous operation.
         pauseBackgroundWorker = true;
         backgroundWorker1.CancelAsync();
     }
 }
コード例 #6
0
        private void SystemTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
        {
            if (_systemTimer != null)
            {
                if (_systemTimer.Enabled)
                {
                    _systemTimer.Stop();
                }
            }

            worker.CancelAsync();
        }
コード例 #7
0
        private void dataGridView1_CellContentClick(object sender, DataGridViewCellEventArgs e)
        {
            try
            {
                if (e.ColumnIndex >= 0 && this.dataGridView1.Columns[e.ColumnIndex].DataPropertyName == "RunQuery")
                {
                    BindingSource bindingSource = this.dataGridView1.DataSource as BindingSource;
                    M2MMatrixCompressionPlugin.M2MMatrixCompressionStat item = bindingSource.Current as M2MMatrixCompressionPlugin.M2MMatrixCompressionStat;
                    item.RunQuery = !item.RunQuery;

                    //flip all with same SQL and intermediate MG name
                    foreach (M2MMatrixCompressionPlugin.M2MMatrixCompressionStat stat in _list)
                    {
                        if (item.IntermediateMeasureGroupName == stat.IntermediateMeasureGroupName && item.SQL == stat.SQL)
                        {
                            stat.RunQuery = item.RunQuery;
                        }
                    }
                    dataGridView1.Refresh();

                    if (item == currentStat)
                    {
                        if (!item.RunQuery)
                        {
                            backgroundWorker.CancelAsync();
                            try
                            {
                                lock (command)
                                {
                                    command.Cancel();
                                }
                            }
                            catch { }
                        }
                        else
                        {
                        }
                    }

                    if (_complete)
                    {
                        _complete = false;
                        FindWork();
                    }
                }
            }
            catch (Exception ex)
            {
                System.Diagnostics.Debug.WriteLine(ex.Message);
            }
        }
コード例 #8
0
        private void okbutton_Click(object sender, EventArgs e)
        {
            if (!string.IsNullOrEmpty(ImgBinFileInfo.ImageBinFileMD5Sum))
            {
                StateChanged?.Invoke(this, ImgBinFileInfo); //
                SystemLog.I(TAG, ImgBinFileInfo);
            }

            if (CalFileMD5work != null && CalFileMD5work.WorkerSupportsCancellation)
            {
                CalFileMD5work?.CancelAsync();
            }
            Dispose();
        }
コード例 #9
0
        public void checkvideoEnd()
        {
            //If we check video end about normal case
            string sCurrentValue;

            sCurrentValue = _driver.FindElement(By.XPath("//*[@id='movie_player']")).GetAttribute("class");
            _isVideoEnd   = this.IsVideoEnded(sCurrentValue);
            //System.Diagnostics.Debug.WriteLine("Player State :", sCurrentValue);

            if (_isVideoEnd == true)
            {
                worker.CancelAsync();
            }
        }
コード例 #10
0
        private void submit_Click(object sender, RoutedEventArgs e)
        {
            //only the admin can start the game

            //when the admin clickes the button the other players should be moved to the game room.

            //genrate a new game id;


            // send start game request.

            mainWindow.Client.startGameRequest(this.gameID);
            backgroundWorker1.CancelAsync();
            _gameFrame.Navigate(new game(gameID));
        }
コード例 #11
0
        public void StartSearch()
        {
            string query = searchentry1.Query;

            if (searchBackgoundWorker != null && searchBackgoundWorker.IsBusy)
            {
                searchBackgoundWorker.CancelAsync();
            }

            if (string.IsNullOrEmpty(query))
            {
                notebook1.Page = 1;
                return;
            }

            this.notebook1.Page = 2;

            switch (searchMode)
            {
            case SearchMode.Member:
                IdeApp.Workbench.StatusBar.BeginProgress(GettextCatalog.GetString("Searching member..."));
                break;

            case SearchMode.Disassembler:
                IdeApp.Workbench.StatusBar.BeginProgress(GettextCatalog.GetString("Searching string in disassembled code..."));
                break;

            case SearchMode.Decompiler:
                IdeApp.Workbench.StatusBar.BeginProgress(GettextCatalog.GetString("Searching string in decompiled code..."));
                break;

            case SearchMode.Type:
                IdeApp.Workbench.StatusBar.BeginProgress(GettextCatalog.GetString("Searching type..."));
                break;
            }
            memberListStore.Clear();
            typeListStore.Clear();

            searchBackgoundWorker = new BackgroundWorker();
            searchBackgoundWorker.WorkerSupportsCancellation = true;
            searchBackgoundWorker.WorkerReportsProgress      = false;
            searchBackgoundWorker.DoWork             += SearchDoWork;
            searchBackgoundWorker.RunWorkerCompleted += delegate {
                searchBackgoundWorker = null;
            };

            searchBackgoundWorker.RunWorkerAsync(query);
        }
コード例 #12
0
ファイル: SinExtract.cs プロジェクト: joeisgood99/PRFCreator
        public static void ExtractSin(BackgroundWorker sender, string sinfile, string outfile, bool log = true)
        {
            using (FileStream stream = new FileStream(sinfile, FileMode.Open, FileAccess.Read))
            using (BinaryReader br = new BinaryReader(stream))
            {
                if (log)
                    Logger.WriteLog("Verifying extracted Sin File"); ;
                if (!SinFile.VerifySin(br))
                {
                    sender.CancelAsync();
                    return;
                }

                List<SinFile.BlockInfoHeader> bihs = null;
                int SinVer = SinFile.GetSinVersion(br);
                switch (SinVer)
                {
                    case 2:
                        bihs = SinFileV2.GetBIHs(br);
                        break;
                    case 3:
                        bihs = SinFileV3.GetBIHs(br);
                        break;
                }
                if (log)
                    Logger.WriteLog("Extracting image from Sin File " + Path.GetFileName(sinfile));

                SinExtract.ExtractSinData(sender, br, bihs, outfile, log);
            }
        }
コード例 #13
0
 private void BtCancel_Click(object sender, RoutedEventArgs e)
 {
     if ((null != bgWorker) && bgWorker.IsBusy)
     {
         bgWorker.CancelAsync();
     }
 }
コード例 #14
0
		public void CancelAsyncNonBusy ()
		{
			BackgroundWorker b = new BackgroundWorker ();
			b.WorkerSupportsCancellation = true;
			Assert.IsFalse (b.IsBusy, "#1");
			b.CancelAsync ();
		}
コード例 #15
0
		MultiProgressDialog(string status, List<string> names, Action<ProgressDelegate, CancelDelegate> work, Action finished = null)
		{
			InitializeComponent();
			Status = status;
			progress = names.Select(name => 0).ToList();
			SetupGrid(names);

			worker = new BackgroundWorker { WorkerReportsProgress = true, WorkerSupportsCancellation = true };
			worker.DoWork += (s, e) =>
			{
				work((child, done, total) => SetProgress(child, done, total), forceCancel =>
				{
					if (forceCancel)
						worker.CancelAsync();
					if (worker.CancellationPending)
						e.Cancel = true;
					return e.Cancel;
				});
			};
			worker.ProgressChanged += (s, e) =>
			{
				for (var ctr = 0; ctr < progressBars.Count; ++ctr)
					progressBars[ctr].Progress = progress[ctr];
			};
			worker.RunWorkerCompleted += (s, e) =>
			{
				canClose = true;
				Close();
				if (e.Error != null)
					throw new Exception($"Background task failed: {e.Error.Message}", e.Error);
				if ((!e.Cancelled) && (finished != null))
					finished();
			};
			worker.RunWorkerAsync();
		}
コード例 #16
0
 private void button_cancel_print_Click(object sender, RoutedEventArgs e)
 {
     if (printWorker.WorkerSupportsCancellation == true)
     {
         printWorker.CancelAsync();
     }
 }
コード例 #17
0
        private void Process()
        {
            var pbViewModel = new ProgressBarViewModel();
            var pbView = new ProgressBarView { DataContext = pbViewModel };
            pbView.Show();

            var worker = new BackgroundWorker();
            worker.WorkerReportsProgress = true;
            worker.WorkerSupportsCancellation = true;
            worker.DoWork += worker_DoWork;
            worker.ProgressChanged += (sender, args) =>
            {
                pbViewModel.Value = args.ProgressPercentage;
            };
            worker.RunWorkerCompleted += (sender, args) =>
            {
                if (args.Cancelled)
                {
                    MessageBox.Show("Расчет прерван");
                }
                pbView.Close();
            };

            pbViewModel.Cancelled += (sender, args) =>
            {
                worker.CancelAsync();
            };

            worker.RunWorkerAsync();
        }
コード例 #18
0
 public void CancleAsync()
 {
     if (!this.mainWorker.WorkerSupportsCancellation)
     {
         mainWorker.CancelAsync();
     }
 }
コード例 #19
0
        public override bool Execute()
        {
            Log.LogMessage(string.Format("Starting to build '{0}'", ApplicationToBuild));

            try
            {
                var aionBuilder = new AionBuilder(AionBuildProcess, null, Log);

                var worker = new BackgroundWorker();
                worker.DoWork += WorkerDoWork;
                worker.WorkerSupportsCancellation = true;
                worker.RunWorkerAsync();

                aionBuilder.Build(ApplicationToBuild, ShouldRestoreCodeFromApp, BuildTimeOutInSeconds);

                worker.CancelAsync();

                Log.LogMessage(string.Format("Finished building '{0}'{1}", ApplicationToBuild, Environment.NewLine));

                return aionBuilder.IsBuildSuccesful;
            }
            catch (Exception e)
            {
                Log.LogError(e.Message + " > " + e.StackTrace);
                return false;
            }
        }
コード例 #20
0
        public void Stop()
        {
            nf.AddToINFO($@"Closing Measurment.");
            Application.DoEvents();
            measWorker.CancelAsync();

            while (measWorker.CancellationPending)
            {
                nf.AddToINFO($@"Cancellation pending...", InfoLine);
                Thread.Sleep(1000);
                measWorker.Dispose();
                Application.DoEvents();
            }
            nf.AddToINFO($@"Measurment is closed.", InfoLine);
            WorkerEndOutput();
            Application.DoEvents();
        }
コード例 #21
0
ファイル: Form1.cs プロジェクト: jefreyadean/gittest
 private void button9_Click(object sender, EventArgs e)
 {
     if (backgroundWorker2.WorkerSupportsCancellation == true)
     {
         // Cancel the asynchronous operation.
         backgroundWorker2.CancelAsync();
     }
 }
コード例 #22
0
 void StopActiveSearch()
 {
     if (searchWorker != null)
     {
         searchWorker.CancelAsync();
     }
     searchWorker = null;
 }
コード例 #23
0
 public void bwStopDataGrid(Object sender, EventArgs e)
 {
     if (bw.WorkerSupportsCancellation == true)
     {
         // Cancel the asynchronous operation.
         bw.CancelAsync();
         // btnStart.Enabled = true;
     }
 }
コード例 #24
0
ファイル: CWebManager.cs プロジェクト: cocoknight/URUTA
        private void SystemTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
        {
            //MessageBox.Show("System Timer Expire!");
            _systemTimer.Stop();

            //TOAN : 06/30/2019. 이제 일을 그만하자.
            worker.CancelAsync();
            System.Diagnostics.Debug.WriteLine(string.Format("[Web Actor]system timer expired"));
        }
コード例 #25
0
 private void Stop10_Click(object sender, EventArgs e)
 {
     if (bw10.WorkerSupportsCancellation == true)
     {
         // Cancel the asynchronous operation.
         bw10.CancelAsync();
         Start10.Enabled = true;
     }
 }
コード例 #26
0
 private void cancelAsyncButton_Click(object sender, EventArgs e)
 {
     if (backgroundWorker1.WorkerSupportsCancellation == true)
     {
         // Cancel the asynchronous operation.
         backgroundWorker1.CancelAsync();
     }
     this.Close();
 }
コード例 #27
0
 private void cmdTrennen_Click(System.Object sender, System.EventArgs e)
 {
     if (client.IsConnected)
     {
         client.LeaveChannel(txtChannel1.Text);
     }
     client.Disconnect();
     backgroundWorker1.CancelAsync();
     backgroundWorker1.Dispose();
 }
コード例 #28
0
        /// <summary>
        /// Executed when the service starts
        /// </summary>
        /// <param name="args"></param>
        protected override void OnStart(string[] args)
        {
            serviceLog.WriteEntry("IntelliMailService started");

            BackgroundWorker worker = new BackgroundWorker();
            worker.DoWork += new DoWorkEventHandler(StartIdleProcess);
            if (worker.IsBusy)
                worker.CancelAsync();

            worker.RunWorkerAsync();
        }
コード例 #29
0
ファイル: frmPAGWizard.cs プロジェクト: maverick126/RSM
        private void backgroundWorker2_DoWork(object sender, DoWorkEventArgs e)
        {
            // Get the BackgroundWorker that raised this event.
            CallParameter cp3 = (CallParameter)e.Argument;

            //this.imagebox.BeginInvoke((Action)(() =>
            //    {
            //        LoadHomeList_MultiThread(cp2.brandid, cp2.pagid);
            //    }));
            e.Result = LoadHomeList_MultiThread(cp3.brandid, cp3.pagid, cp3.storey);
            backgroundWorker2.CancelAsync();
        }
コード例 #30
0
 /// <summary>
 /// 取消文件传输
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="e"></param>
 private void btnCancel_Click(object sender, EventArgs e)
 {
     Result = "Info: 用户取消文件传输!";
     if (backgroundUploadWorker != null && backgroundUploadWorker.IsBusy)
     {
         backgroundUploadWorker.CancelAsync();
     }
     if (backgroundDownloadWorker != null && backgroundDownloadWorker.IsBusy)
     {
         backgroundDownloadWorker.CancelAsync();
     }
 }
コード例 #31
0
ファイル: Program.cs プロジェクト: intech/Checker
        static void Main(string[] args)
        {
            BackgroundWorker bw = new BackgroundWorker();
            bw.DoWork += new DoWorkEventHandler(bw_DoWork);
            bw.WorkerSupportsCancellation = true;
            bw.RunWorkerAsync();

            Console.WriteLine("Window closer started\nPress any key to exit...");
            Console.ReadKey();

            bw.CancelAsync();
            bw.DoWork -= bw_DoWork;
        }
コード例 #32
0
ファイル: DocumentUploader.cs プロジェクト: barrett2474/CMS2
        public DocumentUploader()
        {
            InitializeComponent();

            CmsWebService service = new CmsWebService();

            WindowsIdentity windowsUser = WindowsIdentity.GetCurrent();
            if (windowsUser == null)
            {
                return;
            }

            List<string> temp = windowsUser.Name.Split('\\').ToList();
            User user = service.GetUser(temp.Last());

            ConnectionStringSettings settings = ConfigurationManager.ConnectionStrings["CmsEntities"];
            EntityConnectionStringBuilder builder = new EntityConnectionStringBuilder(settings.ConnectionString);
            SqlConnectionStringBuilder conn = new SqlConnectionStringBuilder(builder.ProviderConnectionString);

            lblTitle.Text = string.Format("Document Version Imports: by {0} into {1} on {2}", user.UserName, conn.InitialCatalog, conn.DataSource);

            mMetaData.UserId = user.Id;
            using (mWorker = new BackgroundWorker())
            {
                mWorker.WorkerSupportsCancellation = true;
                mWorker.WorkerReportsProgress = true;
                mWorker.ProgressChanged += bw_ProgressChanged;
                mWorker.RunWorkerCompleted += bw_RunWorkerCompleted;

                mWorker.DoWork += (s1, e1) =>
                    {
                        try
                        {
                            if (mWorker.CancellationPending)
                            {
                                mWorker.CancelAsync();
                                mWorker.Dispose();
                            }
                            else
                            {
                                //WORK
                                ImportDocuments(mWorker);
                            }
                        }
                        catch (ThreadAbortException)
                        {
                            Thread.ResetAbort();
                        }
                    };
            }
        }
コード例 #33
0
        private void backgroundWorker_DoWork(object sender, DoWorkEventArgs e)
        {
            XmlDocument parsedStream = new XmlDocument();

            parsedStream.Load(filepath);
            XmlNodeList nodes = parsedStream.DocumentElement.SelectNodes("T");

            lines.Clear();
            int count = 0;

            foreach (XmlNode node in nodes)
            {
                string str = "";
                foreach (string s in new String[] { "O_ORDERKEY", "O_TOTALPRICE", "O_ORDERDATE" })
                {
                    str += node.SelectSingleNode(s).InnerText + "\t\t";
                }
                lines.Add(str);
                if (backgroundWorker.CancellationPending == true)
                {
                    backgroundWorker.CancelAsync();
                    return;
                }
                count++;
                if (backgroundWorker.CancellationPending)
                {
                    e.Cancel = true;
                    backgroundWorker.ReportProgress(0);
                    return;
                }
                this.backgroundWorker.ReportProgress(count * 100 / nodes.Count);
                this.Dispatcher.Invoke((Action)(() =>
                {
                    this.UpdateLayout();
                }
                                                ));
            }
        }
コード例 #34
0
        private void cancelAsync()
        {
            if (backgroundWorkerParser.WorkerSupportsCancellation == true)
            {
                // Cancel the asynchronous operation.
                backgroundWorkerParser.CancelAsync();
            }

            if (backgroundWorkerSender.WorkerSupportsCancellation == true)
            {
                // Cancel the asynchronous operation.
                backgroundWorkerSender.CancelAsync();
            }
        }
コード例 #35
0
ファイル: CcuTask.cs プロジェクト: yuanzj/ReserchDownload
 private void UpdateLviStatus(object sender, string msg, Task_Level level)
 {
     if (level == Task_Level.TASK_PASS)
     {
         mTaskStatus = level;
     }
     if (level == Task_Level.TASK_FAIL)
     {
         mTaskStatus = level;
         if (this.CcuWorkTask.IsBusy)//关闭正在运行的线程
         {
             CcuWorkTask.CancelAsync();
             Thread.Sleep(5);
             mCcuEvent.Set();
         }
     }
     if (CcuLviHandler != null)
     {
         TaskArgs mArgs = new TaskArgs();
         mArgs.msg   = msg;
         mArgs.level = level;
         CcuLviHandler(sender, mArgs);
     }
 }
コード例 #36
0
        private void generateReport(List <string> Parsed)
        {
            //Cancel Previous Operaions
            if (backgroundWorkerReport.WorkerSupportsCancellation == true)
            {
                // Cancel the asynchronous operation.
                backgroundWorkerReport.CancelAsync();
            }

            if (!backgroundWorkerReport.IsBusy)
            {
                // Start the asynchronous operation.
                backgroundWorkerReport.RunWorkerAsync(Parsed);
            }
        }
コード例 #37
0
        private bool Stop(bool bRestart)
        {
            Console.WriteLine("D: MainWindow Stop()");
            if (buttonStop.IsEnabled == true && asio.GetStatus() == AsioCS.AsioStatus.Running)
            {
                backgroundWorker1.CancelAsync();
                m_restart = bRestart;
                asio.Stop();
                buttonStop.IsEnabled = false;
                return(true);
            }

            Console.WriteLine("D: MainWindow Stop() 空振り");
            return(false);
        }
コード例 #38
0
        protected override void bulkOCRToolStripMenuItem_Click(object sender, RoutedEventArgs e)
        {
            if (backgroundWorkerBulk != null && backgroundWorkerBulk.IsBusy)
            {
                backgroundWorkerBulk.CancelAsync();
                return;
            }

            BulkDialog bulkDialog = new BulkDialog();

            bulkDialog.InputFolder   = inputFolder;
            bulkDialog.OutputFolder  = outputFolder;
            bulkDialog.OutputFormat  = outputFormat;
            bulkDialog.DeskewEnabled = bulkDeskewEnabled;

            Nullable <bool> dialogResult = bulkDialog.ShowDialog();

            if (dialogResult.HasValue && dialogResult.Value)
            {
                inputFolder       = bulkDialog.InputFolder;
                outputFolder      = bulkDialog.OutputFolder;
                outputFormat      = bulkDialog.OutputFormat;
                bulkDeskewEnabled = bulkDialog.DeskewEnabled;

                this.statusLabel.Content = Properties.Resources.OCRrunning;
                Mouse.OverrideCursor     = Cursors.Wait;
                this.Cursor          = Cursors.Wait;
                this.textBox1.Cursor = Cursors.Wait;
                this.toolStripProgressBar1.IsEnabled  = true;
                this.toolStripProgressBar1.Visibility = Visibility.Visible;
                this.bulkOCRToolStripMenuItem.Header  = Properties.Resources.CancelBulkOCR;

                if (!this.statusForm.IsVisible)
                {
                    this.statusForm.Show();
                }
                else if (this.statusForm.WindowState == WindowState.Minimized)
                {
                    this.statusForm.WindowState = WindowState.Normal;
                }
                this.statusForm.Activate();
                this.statusForm.TextBox.AppendText("\t-- " + Properties.Resources.Beginning_of_task + " --" + Environment.NewLine);

                // start bulk OCR
                stopWatch.Start();
                this.backgroundWorkerBulk.RunWorkerAsync();
            }
        }
コード例 #39
0
        private void stopButton_Click(object sender, EventArgs e)
        {
            try
            {
                // Notify the acquisition thread we are stopping
                acquisitionWorker.CancelAsync();

                // Stop the acquisition. This will cause the acquisition
                // thread to get an "acquisition stopped" error if it is
                // blocked waiting for an image
                _session.Acquisition.Stop();
            }
            catch (ImaqdxException error)
            {
                MessageBox.Show(error.ToString(), "NI-IMAQdx Error");
            }
        }
コード例 #40
0
ファイル: LevelManager.cs プロジェクト: TobieD/Glide
        public void Generate(int size, RenderContext context)
        {
            m_Context = context;

            m_Worker = new BackgroundWorker();

            m_Worker.WorkerReportsProgress = true;
            m_Worker.WorkerSupportsCancellation = true;

            m_Worker.DoWork += bgw_DoWork; //Work Event
            m_Worker.RunWorkerCompleted += m_Worker_RunWorkerCompleted;

            //Event that is run in the background;
            Console.WriteLine("Opening new Thread");
            m_Worker.RunWorkerAsync(size);

            m_Worker.CancelAsync();

            m_Worker.Dispose();
        }
コード例 #41
0
        static void Main(string[] args)
        {
            var bw = new BackgroundWorker();
            bw.WorkerReportsProgress = true;
            bw.WorkerSupportsCancellation = true;

            bw.DoWork += Worker_DoWork;
            bw.ProgressChanged += Worker_ProgressChanged;
            bw.RunWorkerCompleted += Worker_Completed;

            bw.RunWorkerAsync();

            Console.WriteLine("Press C to cancel work");
            do
            {
                if (Console.ReadKey(true).KeyChar == 'C')
                {
                    bw.CancelAsync();
                }

            }
            while(bw.IsBusy);
        }
コード例 #42
0
ファイル: Game.xaml.cs プロジェクト: Bang-Bang-Studios/AI
        private void GetComputerMoveAsynchronously()
        {
            var bw = new BackgroundWorker();
            // define the event handlers
            bw.DoWork += (sender, args) =>
            {
                int winner = gameBrain.CheckForWin();
                if (!gameBrain.MakeComputerMove())
                    bw.CancelAsync();
            };
            bw.RunWorkerCompleted += (sender, args) =>
            {
                if (args.Error != null)  // if an exception occurred during DoWork,
                    MessageBox.Show(args.Error.ToString());  // do your error handling here

                    //Update GUI player
                    int computerMove = gameBrain.GetComputerMove();
                    Rectangle rec = (Rectangle)Board.Children[computerMove];
                    rec.Fill = computerPlayer.Fill;
                    int winner = gameBrain.CheckForWin();
                    if (winner != 0)
                        ShowWinner(winner);
                    else
                        GetComputerRotation();

            };
            bw.RunWorkerAsync();
        }
コード例 #43
0
ファイル: BackgroundWorkerDemo.cs プロジェクト: KanLei/Code
        static void Main(string[] arg)
        {
            _bw = new BackgroundWorker
            {
                WorkerReportsProgress = true,      // 报告工作的进度
                WorkerSupportsCancellation = true  // 支持异步的取消工作
            };
            _bw.DoWork += bw_DoWork;
            _bw.ProgressChanged += bw_ProgressChanged;
            _bw.RunWorkerCompleted += bw_RunWorkerCompleted;

            _bw.RunWorkerAsync("Hello to worker");  // 开始执行

            Console.WriteLine("Press Enter in the next 5 seconds to cancel.");
            Console.ReadLine();

            if (_bw.IsBusy) _bw.CancelAsync();  // 设置 CancellationPending 为 true

            Console.ReadLine();
        }
コード例 #44
0
ファイル: MainForm.cs プロジェクト: Chiefs1982/TNG_Database
        /// <summary>
        /// Imports masters tapes from file.
        /// </summary>
        /// <param name="worker">The worker.</param>
        /// <param name="e">The <see cref="DoWorkEventArgs"/> instance containing the event data.</param>
        private void ImportMasters(BackgroundWorker worker, DoWorkEventArgs e)
        {
            Stream importStream = null;

            //Master List import, has a popup to enter Master Tape to add to
            List<MasterListValues> masterListValues = DataBaseControls.GetAllMasterListItems();
            string[] cameraValues = commonMethod.CameraDropdownItems();
            string masterTapeName = "";
            string cameraMasterName = "";
            bool addMasters = false;
            //create a new form for user to enter tape name
            Form masterPrompt = new Form();
            masterPrompt.Height = 200;
            masterPrompt.Width = 500;
            masterPrompt.SizeGripStyle = SizeGripStyle.Hide;
            masterPrompt.FormBorderStyle = FormBorderStyle.FixedSingle;
            masterPrompt.StartPosition = FormStartPosition.CenterScreen;
            masterPrompt.Text = "Enter Tape Name";

            //Set up items to add to popup box
            Label textLabel = new Label() { Left = 50, Top = 20, Text = "Master Archive to Import" };
            ComboBox inputBox = new ComboBox() { Left = 50, Top = 50, Width = 400 };
            //add items to combobox
            foreach (MasterListValues values in masterListValues)
            {
                inputBox.Items.Add(values.MasterArchive);
            }
            inputBox.SelectedIndex = 0;
            //add media combobox
            ComboBox mediaCombo = new ComboBox() { Left = 50, Top = 75, Width = 200 };
            //add items to combobox
            foreach (string mediaValue in cameraValues)
            {
                mediaCombo.Items.Add(mediaValue);
            }
            mediaCombo.SelectedIndex = 1;
            mediaCombo.KeyPress += (senderCombo, eCombo) => { eCombo.Handled = true; };
            mediaCombo.SelectedIndexChanged += (senderCombo, eCombo) => { textLabel.Focus(); };
            //Check for names in the filename
            #region Check for names in File
            try
            {
                //check to make sure there is something selected
                if (!ofd.FileName.Equals(string.Empty))
                {
                    //get name of file without extension
                    string nameFile = Path.GetFileNameWithoutExtension(ofd.FileName);
                    //get index of the word master
                    int index = nameFile.ToLower().IndexOf("master");

                    if(index != -1)
                    {
                        //get substring to include "master ddd"
                        nameFile = nameFile.Substring(index);

                        //check to make sure the last character is a digit
                        while (!char.IsDigit(nameFile[nameFile.Length - 1]))
                        {
                            nameFile = nameFile.Remove(nameFile.Length - 1, 1);
                        }

                        //convert name to lowercasse and then camelcase
                        TextInfo textInfo = new CultureInfo("en-US", false).TextInfo;
                        nameFile = textInfo.ToTitleCase(nameFile.ToLower());

                        //add name of master tape if not included
                        if (!inputBox.Items.Contains(nameFile))
                        {
                            inputBox.Items.Add(nameFile);
                        }
                        inputBox.Text = nameFile;
                    }
                }
            }
            catch { Debug.WriteLine("Error in master gather"); }

            //check if there is a media defined in the name using all combobox items
            try
            {
                //check to make sure there is something selected
                if (!ofd.FileName.Equals(string.Empty))
                {

                    //get name of file without extension
                    foreach (string obj in mediaCombo.Items)
                    {
                        Debug.WriteLine("In media for loop");
                        if (!obj.ToLower().Equals("other"))
                        {
                            Debug.WriteLine("Does not equal other");
                            //string[] mediaItems = mediaCombo.DataSource.t
                            string nameFile = Path.GetFileNameWithoutExtension(ofd.FileName);

                            //get index of the word master
                            int index = nameFile.ToLower().IndexOf(obj.ToLower());

                            //add name of master tape if not included
                            if (index != -1)
                            {
                                Debug.WriteLine("Does not equal -1");
                                mediaCombo.Text = obj;
                                break;
                            }
                        }

                    }
                }
            }
            catch { Debug.WriteLine("Error in media gather"); }

            #endregion

            //Set up buttons to add
            Button confirmation = new Button() { Text = "OK", Left = 240, Width = 100, Top = 120 };
            Button cancelButton = new Button() { Text = "Cancel", Left = 350, Width = 100, Top = 120 };
            //button actions
            cancelButton.Click += (senderPrompt, ePrompt) => { addMasters = false; masterPrompt.Close(); };
            confirmation.Click += (senderPrompt, ePrompt) => { addMasters = true; masterTapeName = inputBox.Text; cameraMasterName = mediaCombo.Text; masterPrompt.Close(); };
            //Add items to form
            masterPrompt.Controls.Add(textLabel);
            masterPrompt.Controls.Add(inputBox);
            masterPrompt.Controls.Add(mediaCombo);
            masterPrompt.Controls.Add(confirmation);
            masterPrompt.Controls.Add(cancelButton);
            masterPrompt.ShowDialog();
            //Add entries or Cancel depending on button clicked
            if (addMasters)
            {
                //gets extension of the file and acts accordingly
                switch (GetExtensionOfFile(ofd))
                {
                    case "csv":
                        UpdateStatusBarBottom("Importing " + masterTapeName + " Entries");
                        DataBaseControls.AddMasterTapesFromFile(worker, importStream, ofd, masterTapeName, commonMethod.GetCameraNumber(cameraMasterName));
                        break;
                    case "txt":
                        ofd.FileName = @"" + TempConvertToCSV(ofd);
                        UpdateStatusBarBottom("Importing " + masterTapeName + " Entries");
                        DataBaseControls.AddMasterTapesFromFile(worker, importStream, ofd, masterTapeName, commonMethod.GetCameraNumber(cameraMasterName), true);
                        break;
                    case "doc":
                    case "docx":
                        ofd.FileName = @"" + ConvertWordToCSVFile(ofd);
                        UpdateStatusBarBottom("Importing " + masterTapeName + " Entries");
                        DataBaseControls.AddMasterTapesFromFile(worker, importStream, ofd, masterTapeName, commonMethod.GetCameraNumber(cameraMasterName), true);
                        break;
                    default:
                        Debug.WriteLine("File was not a txt, doc, docx, or csv");
                        break;
                }

            }
            else
            {
                worker.CancelAsync();
                if (worker.CancellationPending)
                {
                    e.Cancel = true;
                    return;
                }
            }
        }
コード例 #45
0
        internal void Merge()
        {
            Type ilMergeType = null;
            Type ilMergeKind = null;
            try
            {
                Assembly assembly = Assembly.LoadFrom(Settings.Default.ILMergePath);

                ilMergeType = assembly.GetType("ILMerging.ILMerge");
                ilMergeKind = assembly.GetType("ILMerging.ILMerge+Kind");
            }
            catch (Exception e)
            {
                OnError("Can't create ILMerge object.", e);
                return;
            }

            try
            {
                //Create ILMerge object
                Object[] args = new Object[] { };
                Object obj = ilMergeType.InvokeMember(null,
                    BindingFlags.DeclaredOnly |
                    BindingFlags.Public | BindingFlags.NonPublic |
                    BindingFlags.Instance | BindingFlags.CreateInstance, null, null, args);

                ilMergeType.InvokeMember("Log",
                    BindingFlags.DeclaredOnly |
                    BindingFlags.Public | BindingFlags.NonPublic |
                    BindingFlags.Instance | BindingFlags.SetProperty, null, obj, new Object[] { Settings.Default.ShouldLog });

                Object objKind = ilMergeKind.InvokeMember(null,
                    BindingFlags.DeclaredOnly |
                    BindingFlags.Public | BindingFlags.NonPublic |
                    BindingFlags.Instance | BindingFlags.CreateInstance, null, null, args);

                ilMergeKind.InvokeMember("value__",
                    BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static |
                    BindingFlags.Instance | BindingFlags.SetField, null, objKind, new Object[] { (int)Settings.Default.TargetKind });

                ilMergeType.InvokeMember("TargetKind",
                    BindingFlags.DeclaredOnly |
                    BindingFlags.Public | BindingFlags.NonPublic |
                    BindingFlags.Instance | BindingFlags.SetProperty, null, obj, new Object[] { objKind });

                ilMergeType.InvokeMember("AllowWildCards",
                    BindingFlags.DeclaredOnly |
                    BindingFlags.Public | BindingFlags.NonPublic |
                    BindingFlags.Instance | BindingFlags.SetProperty, null, obj, new Object[] { Settings.Default.AllowWildCards });

                ilMergeType.InvokeMember("AllowZeroPeKind",
                    BindingFlags.DeclaredOnly |
                    BindingFlags.Public | BindingFlags.NonPublic |
                    BindingFlags.Instance | BindingFlags.SetProperty, null, obj, new Object[] { Settings.Default.AllowZeroPEKind });

                ilMergeType.InvokeMember("Closed",
                    BindingFlags.DeclaredOnly |
                    BindingFlags.Public | BindingFlags.NonPublic |
                    BindingFlags.Instance | BindingFlags.SetProperty, null, obj, new Object[] { Settings.Default.Closed });

                PropertyInfo pi = ilMergeType.GetProperty("XmlDocumentation");
                if (pi != null)
                {
                    ilMergeType.InvokeMember("XmlDocumentation",
                        BindingFlags.DeclaredOnly |
                        BindingFlags.Public | BindingFlags.NonPublic |
                        BindingFlags.Instance | BindingFlags.SetProperty, null, obj, new Object[] { Settings.Default.XmlDocumentation });
                }

                ilMergeType.InvokeMember("CopyAttributes",
                    BindingFlags.DeclaredOnly |
                    BindingFlags.Public | BindingFlags.NonPublic |
                    BindingFlags.Instance | BindingFlags.SetProperty, null, obj, new Object[] { Settings.Default.CopyAttributes });

                ilMergeType.InvokeMember("DebugInfo",
                    BindingFlags.DeclaredOnly |
                    BindingFlags.Public | BindingFlags.NonPublic |
                    BindingFlags.Instance | BindingFlags.SetProperty, null, obj, new Object[] { Settings.Default.DebugInfo });

                ilMergeType.InvokeMember("Internalize",
                    BindingFlags.DeclaredOnly |
                    BindingFlags.Public | BindingFlags.NonPublic |
                    BindingFlags.Instance | BindingFlags.SetProperty, null, obj, new Object[] { Settings.Default.Internalize });

                ilMergeType.InvokeMember("PublicKeyTokens",
                    BindingFlags.DeclaredOnly |
                    BindingFlags.Public | BindingFlags.NonPublic |
                    BindingFlags.Instance | BindingFlags.SetProperty, null, obj, new Object[] { Settings.Default.PublicKeyTokens });

                pi = ilMergeType.GetProperty("DelaySign");
                if (pi != null)
                {
                    ilMergeType.InvokeMember("DelaySign",
                        BindingFlags.DeclaredOnly |
                        BindingFlags.Public | BindingFlags.NonPublic |
                        BindingFlags.Instance | BindingFlags.SetProperty, null, obj, new Object[] { Settings.Default.DelaySign });
                }


                pi = ilMergeType.GetProperty("AllowDuplicateType");
                if (Settings.Default.AllowDuplicateType && pi != null)
                {
                    object[] dublArgs;
                    if (Settings.Default.DuplicateTypeName == "All types")
                        dublArgs = new object[] { null };
                    else
                        dublArgs = new object[] { Settings.Default.DuplicateTypeName };

                    ilMergeType.InvokeMember("AllowDuplicateType",
                        BindingFlags.DeclaredOnly |
                        BindingFlags.Public | BindingFlags.NonPublic |
                        BindingFlags.Instance | BindingFlags.InvokeMethod, null, obj, dublArgs);
                }

                pi = ilMergeType.GetProperty("Version");

                if (pi != null && Settings.Default.Version.Trim() != "")
                {
                    Version version = new Version(Settings.Default.Version);
                    ilMergeType.InvokeMember("Version",
                        BindingFlags.DeclaredOnly |
                        BindingFlags.Public | BindingFlags.NonPublic |
                        BindingFlags.Instance | BindingFlags.SetProperty, null, obj, new Object[] { version });
                }


                if (!string.IsNullOrEmpty(KeyFile))
                {
                    ilMergeType.InvokeMember("SnkFile",
                        BindingFlags.DeclaredOnly |
                        BindingFlags.Public | BindingFlags.NonPublic |
                        BindingFlags.Instance | BindingFlags.SetProperty, null, obj, new Object[] { KeyFile });

                }
                if (!string.IsNullOrEmpty(AttributeFile))
                {
                    ilMergeType.InvokeMember("AttributeFile",
                        BindingFlags.DeclaredOnly |
                        BindingFlags.Public | BindingFlags.NonPublic |
                        BindingFlags.Instance | BindingFlags.SetProperty, null, obj, new Object[] { AttributeFile });

                }
                if (!string.IsNullOrEmpty(ExcludeFile))
                {
                    ilMergeType.InvokeMember("ExcludeFile",
                        BindingFlags.DeclaredOnly |
                        BindingFlags.Public | BindingFlags.NonPublic |
                        BindingFlags.Instance | BindingFlags.SetProperty, null, obj, new Object[] { ExcludeFile });
                }

                if (!string.IsNullOrEmpty(LogFile))
                {
                    ilMergeType.InvokeMember("LogFile",
                        BindingFlags.DeclaredOnly |
                        BindingFlags.Public | BindingFlags.NonPublic |
                        BindingFlags.Instance | BindingFlags.SetProperty, null, obj, new Object[] { LogFile });
                }
                ilMergeType.InvokeMember("OutputFile",
                    BindingFlags.DeclaredOnly |
                    BindingFlags.Public | BindingFlags.NonPublic |
                    BindingFlags.Instance | BindingFlags.SetProperty, null, obj, new Object[] { OutputFile });

                string[] assemblies = new string[OtherAssemblies.Count + 1];
                assemblies[0] = PrimaryAssembly;
                int i = 1;
                foreach (string item in OtherAssemblies )
                {
                    assemblies[i] = item;
                    i++;
                }
                ilMergeType.InvokeMember("SetInputAssemblies",
                    BindingFlags.DeclaredOnly |
                    BindingFlags.Public | BindingFlags.NonPublic |
                    BindingFlags.Instance | BindingFlags.InvokeMethod, null, obj, new Object[] { assemblies });


                BackgroundWorker logReaderWorker = new BackgroundWorker();
                logReaderWorker.DoWork += new DoWorkEventHandler(logReaderWorker_DoWork);
                logReaderWorker.WorkerSupportsCancellation = true;
                logReaderWorker.RunWorkerAsync();
                

                ilMergeType.InvokeMember("Merge",
                    BindingFlags.DeclaredOnly |
                    BindingFlags.Public | BindingFlags.NonPublic |
                    BindingFlags.Instance | BindingFlags.InvokeMethod, null, obj, new Object[] { });

                obj = null;
                objKind = null;
                ilMergeType = null;
                ilMergeKind = null;
                logReaderWorker.CancelAsync();
            }
            catch (Exception ex)
            {
                OnError("Merge error", ex);
            }
        }
コード例 #46
0
        public void Backgrounf_worker_cancellation_and_progress()
        {
            var backgroundWorker = new BackgroundWorker {WorkerReportsProgress = true, WorkerSupportsCancellation = true};

            backgroundWorker.DoWork += (sender, args) =>
            {
                for (var i = 0; i < 100; i += 20)
                {
                    if (backgroundWorker.CancellationPending)
                    {
                        args.Cancel = true;
                        return;
                    }
                    backgroundWorker.ReportProgress(i);
                    Thread.Sleep(1000);
                }

                args.Result = 123;
            };

            backgroundWorker.ProgressChanged += (sender, args) => Console.WriteLine("Reached " + args.ProgressPercentage + "%");
            backgroundWorker.RunWorkerCompleted += (sender, args) =>
            {
                if (args.Cancelled)
                {
                    Console.WriteLine("You cancelled!");
                }
                else if (args.Error != null)
                {
                    Console.WriteLine("Worker Exception: " + args.Error.ToString());
                }
                else
                {
                    Console.WriteLine("Completed: " + args.Result);
                }
            };

            backgroundWorker.RunWorkerAsync("Hello to worker");

            Thread.Sleep(2000);
            if(backgroundWorker.IsBusy) backgroundWorker.CancelAsync();

            Thread.Sleep(1100); //wait for last loop
        }
コード例 #47
0
ファイル: UCSpares.xaml.cs プロジェクト: bashlykevich/Bycar
        private void LoadSparesInBackground()
        {
            ParentWindow.edtStatus.Content = "загрузка...";
            SelectedSpareID = 0;
            if (dgSpares.SelectedItem != null)
                SelectedSpareID = (dgSpares.SelectedItem as SpareView).id;

            BackgroundLoad = new BackgroundWorker();
            BackgroundLoad.DoWork += new DoWorkEventHandler(BackgroundLoad_DoWork);
            BackgroundLoad.RunWorkerCompleted += new RunWorkerCompletedEventHandler(BackgroundLoad_RunWorkerCompleted);
            if (BackgroundLoad.IsBusy)
                BackgroundLoad.CancelAsync();
            BackgroundLoad.RunWorkerAsync();
        }
コード例 #48
0
ファイル: UCSpares.xaml.cs プロジェクト: bashlykevich/Bycar
 private void ShowSpareDetailsInBackground(IList selectedItems)
 {
     ParentWindow.edtStatus.Content = "загрузка";
     BackgroundShowDetails = new BackgroundWorker();
     BackgroundShowDetails.DoWork += new DoWorkEventHandler(BackgroundShowDetails_DoWork);
     BackgroundShowDetails.RunWorkerCompleted += new RunWorkerCompletedEventHandler(BackgroundShowDetails_RunWorkerCompleted);
     if (BackgroundShowDetails.IsBusy)
         BackgroundShowDetails.CancelAsync();
     BackgroundShowDetails.RunWorkerAsync(selectedItems);
 }
コード例 #49
0
        private void StartContentBuilding()
        {
            BackgroundWorker worker = new BackgroundWorker();
            worker.WorkerReportsProgress = true;
            worker.WorkerSupportsCancellation = true;

            #region Events
            worker.DoWork += delegate(object s, DoWorkEventArgs args)
            {
                EditorStatus = EditorStatus.LOADING;
                Database.Instance.LoadData();

                progressStatusBarItem.Dispatcher.Invoke(
                  System.Windows.Threading.DispatcherPriority.Normal,
                  new Action(
                    delegate()
                    {
                        progressStatusBarItem.Content = "Building content...";
                    }
                ));

                #region Resource Builder Events
                ResourceBuilder.Instance.OnPercentChanged += new EventHandler<OnPercentChangedEventArgs>(delegate(object o, OnPercentChangedEventArgs OnPercentChangedEventArgs)
                {
                    worker.ReportProgress(OnPercentChangedEventArgs.Percent);
                });

                ResourceBuilder.Instance.OnBuildFailed +=  new EventHandler<EventArgs>(delegate(object onBuildFailed, EventArgs onBuildFailedArgs)
                {
                    worker.CancelAsync();
                });
                #endregion

                ResourceBuilder.Instance.BuildContent();
            };

            worker.ProgressChanged += delegate(object s, ProgressChangedEventArgs args)
            {
                int percentage = args.ProgressPercentage;

                progressBar.Value = percentage;
            };

            worker.RunWorkerCompleted += delegate(object s, RunWorkerCompletedEventArgs args)
            {
                EditorStatus = EditorStatus.IDLE;
                progressStatusBarItem.Content = "Ready";
                progressBar.Value = 0;
                Output.AddToOutput("Building of content files completed...");
                sceneGraph.Lighting.LoadContent();

                gizmo = new GizmoModules.GizmoComponent(GameApplication.Instance.GetGraphics(), spriteBatch);
                gizmo.SetSelectionPool(WorldManager.Instance.GetActors().Values);
                gizmo.ActiveSpace = GizmoModules.TransformSpace.Local;
                gizmo.TranslateEvent += new GizmoModules.TransformationEventHandler(gizmo_TranslateEvent);
                gizmo.RotateEvent += new TransformationEventHandler(GizmoRotateEvent);
                gizmo.ScaleEvent += new TransformationEventHandler(GizmoScaleEvent);

                // Set up the frame update timer
                timer = new Timer();

                xnaControl.ResetMouseState();

            };
            #endregion

            worker.RunWorkerAsync();
        }
コード例 #50
0
		public void CancelAsyncNoCancellationSupported ()
		{
			BackgroundWorker b = new BackgroundWorker ();
			Assert.IsFalse (b.IsBusy, "#1");
			b.CancelAsync ();
		}
コード例 #51
0
        private void GetComputerMoveAsynchronously()
        {
            var bw = new BackgroundWorker();
            // define the event handlers
            bw.DoWork += (sender, args) =>
            {
                Console.WriteLine("Started AI thread.");
                int winner = gameBrain.CheckForWin();
                if (!gameBrain.MakeComputerMove() || winner != 0)
                {
                    Console.WriteLine("Cancelled AI thread.");
                    bw.CancelAsync();
                    if (winner != 0)
                        ShowWinner(winner);
                }
            };
            bw.RunWorkerCompleted += (sender, args) =>
            {
                if (args.Error != null)  // if an exception occurred during DoWork,
                {
                    Console.WriteLine("Something went wrong with AI thread.");
                    MessageBox.Show(args.Error.ToString());  // do your error handling here
                }

                Console.WriteLine("Good with AI thread.");
                int winner = gameBrain.CheckForWin();
                if (winner == 0)
                {
                    //Update GUI player
                    int computerMove = gameBrain.GetComputerMove();
                    Rectangle rec = (Rectangle)Board.Children[computerMove];
                    rec.Fill = computerPlayer.Image;
                    RePaintBoard();
                    winner = gameBrain.CheckForWin();
                    if (winner != 0)
                        ShowWinner(winner);
                    else
                        GetComputerRotation();
                }
                else if (winner != 0)
                {
                    RePaintBoard();
                    ShowWinner(winner);
                }

            };
            bw.RunWorkerAsync();
        }
コード例 #52
0
        /// <summary>
        /// Initiates a single form publishing process
        /// </summary>
        private void DoPublish()
        {
            UserPublishGuid = Guid.NewGuid();
            txtSurveyName.Enabled = false;
            txtSurveyID.Enabled = false;
            txtOrganization.Enabled = false;
            txtDepartment.Enabled = false;
            txtIntroductionText.Enabled = false;
            txtExitText.Enabled = false;
            dtpSurveyClosingDate.Enabled = false;
            txtOrganizationKey.Enabled = false;
            btnPrevious.Enabled = false;
            txtStatus.Clear();
            txtURL.Clear();
            this.tabPublishWebForm.SelectedTab = this.tabPublishWebForm.TabPages[2];

            btnPublishForm.Enabled = true;
            progressBar.Visible = true;

            stopwatch = new Stopwatch();
            stopwatch.Start();

            Epi.Web.Common.Message.PublishRequest Request = new Epi.Web.Common.Message.PublishRequest();

            if (string.IsNullOrEmpty(ClosingTimecomboBox.Text))
            {
                Request.SurveyInfo.ClosingDate = dtpSurveyClosingDate.Value.Date + new TimeSpan(0, 23, 59, 0);
            }
            else
            {
                Request.SurveyInfo.ClosingDate = GetdateTimeFormat(dtpSurveyClosingDate.Value.Date, ClosingTimecomboBox.Text);
            }

            if (string.IsNullOrEmpty(StartTimecomboBox.Text))
            {
                Request.SurveyInfo.StartDate = StartDateDatePicker.Value.Date;
            }
            else
            {
                Request.SurveyInfo.StartDate = GetdateTimeFormat(StartDateDatePicker.Value.Date, StartTimecomboBox.Text);
            }

            Request.SurveyInfo.DepartmentName = txtDepartment.Text;
            Request.SurveyInfo.IntroductionText = txtIntroductionText.Text;
            Request.SurveyInfo.ExitText = txtExitText.Text;

            Request.SurveyInfo.SurveyName = txtSurveyName.Text;

            Request.SurveyInfo.OrganizationKey = new Guid(txtOrganizationKey.Text.ToString());
            Request.SurveyInfo.UserPublishKey = UserPublishGuid;
            Request.SurveyInfo.XML = template;
            Request.SurveyInfo.IsDraftMode = true;
            Request.SurveyInfo.SurveyType = (rdbSingleResponse.Checked) ? 1 : 2;
            if (txtOrganization.Text.Equals("Your Organization Name (optional)", StringComparison.OrdinalIgnoreCase))
            {
                Request.SurveyInfo.OrganizationName = null;
            }
            else
            {
                Request.SurveyInfo.OrganizationName = txtOrganization.Text;
            }

            if (txtSurveyID.Text.Equals("Your Survey ID (optional)", StringComparison.OrdinalIgnoreCase))
            {
                Request.SurveyInfo.SurveyNumber = null;
            }
            else
            {
                Request.SurveyInfo.SurveyNumber = txtSurveyID.Text;
            }

            Configuration config = Configuration.GetNewInstance();
            try
            {
                if (config.Settings.Republish_IsRepbulishable)
                {
                    Request.SurveyInfo.IsDraftMode = true;
                }
                else
                {
                    Request.SurveyInfo.IsDraftMode = false;
                }

            }
            catch (Exception ex)
            {
                Request.SurveyInfo.IsDraftMode = false;
            }
            try
            {
                Epi.Web.Common.Message.PublishResponse Result = new Epi.Web.Common.Message.PublishResponse();
                lock (syncLock)
                {
                    this.Cursor = Cursors.WaitCursor;
                    publishWorker = new BackgroundWorker();
                    publishWorker.WorkerSupportsCancellation = true;
                    publishWorker.DoWork += new System.ComponentModel.DoWorkEventHandler(worker_DoWork);
                    publishWorker.RunWorkerCompleted += new System.ComponentModel.RunWorkerCompletedEventHandler(worker_WorkerCompleted);
                    object[] args = new object[2];
                    args[0] = Request;
                    args[1] = Result;
                    publishWorker.RunWorkerAsync(args);
                }

                if (publishWorker.WorkerSupportsCancellation)
                {
                    publishWorker.CancelAsync();
                }
            }
            catch (Exception ex)
            {
                txtStatusSummary.AppendText("An error occurred while trying to publish the survey.");
                txtStatus.AppendText(ex.ToString());
                btnDetails.Visible = true;
                this.progressBar.Visible = false;
                this.Cursor = Cursors.Default;
            }
        }
コード例 #53
0
        private void _workerTotalProcess_DoWork(object sender, DoWorkEventArgs e)
        {
            _worker2 = sender as BackgroundWorker;
           
            _index = _index + 1;

            _checkImportDone = new DelImportProcess(ImportProcess);
            IAsyncResult ar = _checkImportDone.BeginInvoke(new AsyncCallback(ImportComplete), new object());
            while (!ar.IsCompleted)
            {
                ar.AsyncWaitHandle.WaitOne(1, false);
            }

            if (ar.IsCompleted == true)
            {
                if (_rImport == true)
                {
                    //_workerTotalProcess_RunWorkerCompleted(sender, new RunWorkerCompletedEventArgs(ar.AsyncState, null, false));
                }
                else
                {
                    e.Cancel = true;
                    _worker2.CancelAsync();
                    return;
                }
            }
            if (_worker2.CancellationPending)
            {
                e.Cancel = true;
                return;
            }
        }
コード例 #54
0
        private void matchingOnlyToolStripMenuItem_Click(object sender, EventArgs e)
        {
            try
            {
                OpenXsd(1);
            }
            catch (NineDragons.XStringDatabase.Exception ex)
            {
                MessageBox.Show(ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                return;
            }

            mergeWorker = new BackgroundWorker();
            mergeWorker.WorkerSupportsCancellation = true;
            mergeWorker.DoWork += new DoWorkEventHandler(this.MergeWorker_DoWork);
            mergeWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(this.MergeWorker_RunWorkerCompleted);
            busySectionPanel.Visible = true;

            if (mergeWorker.IsBusy && mergeWorker.WorkerSupportsCancellation)
                mergeWorker.CancelAsync();
            else
                mergeWorker.RunWorkerAsync(new MergeXsdDelegate(DelegateMergeXsd));
        }
コード例 #55
0
        private void PerformAction(string actionName, Project project, Cloud cloud, ProjectDirectories dir,
            Action<IVcapClient, DirectoryInfo> action)
        {
            var worker = new BackgroundWorker();

            Messenger.Default.Register<NotificationMessageAction<string>>(this,
                message =>
                {
                    if (message.Notification.Equals(Messages.SetProgressData))
                        message.Execute(actionName);
                });

            var window = new ProgressDialog();
            var dispatcher = window.Dispatcher;
            var helper = new WindowInteropHelper(window);
            helper.Owner = (IntPtr)(dte.MainWindow.HWnd);
            worker.WorkerSupportsCancellation = true;
            worker.DoWork += (s, args) =>
            {
                if (worker.CancellationPending) { args.Cancel = true; return; }

                Messenger.Default.Send(new ProgressMessage(0, "Starting " + actionName));

                if (worker.CancellationPending) { args.Cancel = true; return; }

                if (!Directory.Exists(dir.StagingPath))
                {
                    dispatcher.BeginInvoke((Action)(() => Messenger.Default.Send(new ProgressMessage(10, "Creating Staging Path"))));
                    Directory.CreateDirectory(dir.StagingPath);
                }

                if (worker.CancellationPending) { args.Cancel = true; return; }

                if (Directory.Exists(dir.DeployFromPath))
                {
                    dispatcher.BeginInvoke((Action)(() => Messenger.Default.Send(new ProgressMessage(10, "Creating Precompiled Site Path"))));
                    Directory.Delete(dir.DeployFromPath, true);
                }

                if (worker.CancellationPending) { args.Cancel = true; return; }

                dispatcher.BeginInvoke((Action)(() => Messenger.Default.Send(new ProgressMessage(30, "Preparing Compiler"))));

                VsWebSite.VSWebSite site = project.Object as VsWebSite.VSWebSite;
                if (site != null)
                {
                    site.PreCompileWeb(dir.DeployFromPath, true);
                }
                else
                {
                    string frameworkPath = (site == null) ? project.GetFrameworkPath() : String.Empty;

                    if (worker.CancellationPending) { args.Cancel = true; return; }
                    string objDir = Path.Combine(dir.ProjectDirectory, "obj");
                    if (Directory.Exists(objDir))
                    {
                        Directory.Delete(objDir, true); // NB: this can cause precompile errors
                    }

                    var process = new System.Diagnostics.Process()
                    {
                        StartInfo = new ProcessStartInfo()
                        {
                            FileName = Path.Combine(frameworkPath, "aspnet_compiler.exe"),
                            Arguments = String.Format("-nologo -v / -p \"{0}\" -f -u -c \"{1}\"", dir.ProjectDirectory, dir.DeployFromPath),
                            CreateNoWindow = true,
                            ErrorDialog = false,
                            UseShellExecute = false,
                            RedirectStandardOutput = true
                        }
                    };

                    if (worker.CancellationPending) { args.Cancel = true; return; }
                    dispatcher.BeginInvoke((Action)(() => Messenger.Default.Send(new ProgressMessage(40, "Precompiling Site"))));
                    process.Start();
                    string output = process.StandardOutput.ReadToEnd();
                    process.WaitForExit();
                    if (process.ExitCode != 0)
                    {
                        string message = "Asp Compile Error";
                        if (false == String.IsNullOrEmpty(output))
                        {
                            message += ": " + output;
                        }
                        dispatcher.BeginInvoke((Action)(() => Messenger.Default.Send(new ProgressError(message))));
                        return;
                    }
                }

                dispatcher.BeginInvoke((Action)(() => Messenger.Default.Send(new ProgressMessage(50, "Logging in to Cloud Foundry"))));

                if (worker.CancellationPending) { args.Cancel = true; return; }

                var client = new VcapClient(cloud);
                try
                {
                    client.Login();
                }
                catch (Exception e)
                {
                    dispatcher.BeginInvoke((Action)(() => Messenger.Default.Send(new ProgressError("Failure: " + e.Message))));
                    return;
                }

                dispatcher.BeginInvoke((Action)(() => Messenger.Default.Send(new ProgressMessage(75, "Sending to " + cloud.Url))));
                if (worker.CancellationPending) { args.Cancel = true; return; }

                try
                {
                    action(client, new DirectoryInfo(dir.DeployFromPath));
                }
                catch (Exception e)
                {
                    dispatcher.BeginInvoke((Action)(() => Messenger.Default.Send(new ProgressError("Failure: " + e.Message))));
                    return;
                }
                dispatcher.BeginInvoke((Action)(() => Messenger.Default.Send(new ProgressMessage(100, actionName + " complete."))));
            };

            worker.RunWorkerAsync();
            if (!window.ShowDialog().GetValueOrDefault())
            {
                worker.CancelAsync();
            }
        }
コード例 #56
0
        private bool OpenXsd(int xsdIndex)
        {
            string filename = OpenXsdDialog();
            if (filename == string.Empty)
                return false;

            if (xsdIndex == 0)
                xsd.Clear();

            if (xsdIndex > 0 && !(xsd[0] is Xsd))
                MessageBox.Show("Cannot open additional XSDs. Try loading an XSD.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Warning);

            xsd.Insert(xsdIndex, (new XsdFile(filename, keys)));

            if (xsdIndex == 0)
            {
                loadWorker = new BackgroundWorker();
                loadWorker.WorkerSupportsCancellation = true;
                loadWorker.DoWork += new DoWorkEventHandler(this.LoadWorker_DoWork);
                loadWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(this.LoadWorker_RunWorkerCompleted);
                busySectionPanel.Visible = true;

                if (loadWorker.IsBusy && loadWorker.WorkerSupportsCancellation)
                    loadWorker.CancelAsync();
                else
                    loadWorker.RunWorkerAsync(xsdIndex);
            }
            else
            {
                xsd[xsdIndex].load();
            }

            return true;
        }
コード例 #57
0
        public static int getCPUCores()
        {
            BackgroundWorker bw1 = new BackgroundWorker();
                bw1.WorkerSupportsCancellation = true;

                threadsCounter = 0;

                bw1.DoWork += new DoWorkEventHandler(bw_DoWork);
                bw1.RunWorkerAsync();

                System.Threading.Thread.Sleep(200);

                int singleThreadCount = threadsCounter;

                bw1.CancelAsync();

                threadsCounter = 0;

                BackgroundWorker[] bwm = new BackgroundWorker[8];
                for (int i = 0; i < 8; i++)
                {
                    bwm[i] = new BackgroundWorker();
                    bwm[i].WorkerSupportsCancellation = true;
                    bwm[i].DoWork += new DoWorkEventHandler(bw_DoWork);
                    bwm[i].RunWorkerAsync();
                }

                System.Threading.Thread.Sleep(200);

                int eightThreadsCount = threadsCounter;

                for (int i = 0; i < 8; i++)
                {
                    bwm[i].CancelAsync();
                }

                float performanceRatio = (float)eightThreadsCount / singleThreadCount;

                int cpuCores = 1;

                if (performanceRatio > 7)
                {
                    cpuCores = 8;
                }
                else
                    if (performanceRatio > 3.5)
                    {
                        cpuCores = 4;
                    }
                    else

                        if (performanceRatio > 1.7)
                        {
                            cpuCores = 2;
                        }

                return cpuCores;
        }
コード例 #58
0
        public void Button_Click(object sender, View.ViewButton eventHandler)
        {
            Debug.WriteLine(eventHandler.ToString() + " Clicked");

            switch (eventHandler)
            {
                case View.ViewButton.RandomMap:
                    mapType = Map.MapType.Random;
                    break;
                case View.ViewButton.EmptyMap:
                    mapType = Map.MapType.Empty;
                    break;
                case View.ViewButton.ResetMap:
                    DrawingControl.SuspendDrawing(view.getPanelMap());
                    model.Reset(true);
                    DrawingControl.ResumeDrawing(view.getPanelMap());
                    break;
            }

            switch (eventHandler)
            {
                case View.ViewButton.RandomMap:
                case View.ViewButton.EmptyMap:
                    /* save the temp variables */
                    model.getSimulation().set(View.ViewNumericUpDown.MapSize, tempMapSize);
                    model.getSimulation().setCellSize(view.PANEL_SIZE / tempMapSize);
                    model.getSimulation().set(View.ViewNumericUpDown.PercentWalkable, tempPercentWalkable);
                    model.getSimulation().set(View.ViewNumericUpDown.NumberOfAgents, tempNumberofAgents);

                    /* generate map */
                    generateMapCommon(null, true);

                    /* initialize the node edit variables */
                    nodeEditStartAgentId = Agent.AgentID.Agent_0;
                    nodeEditFinishAgentId = Agent.AgentID.Agent_0;
                    nodeEditBackColor = model.getAgent(Agent.AgentID.Agent_0).getColor(Agent.ColorType.BackColor);
                    nodeEditForeColor = model.getAgent(Agent.AgentID.Agent_0).getColor(Agent.ColorType.ForeColor);

                    /* update view */
                    view.updateAgentItems();
                    view.getButton(View.ViewButton.Start).Enabled = true;
                    view.getRadioButton(View.ViewRadioButton.EditWalkable).Enabled = true;
                    view.getRadioButton(View.ViewRadioButton.EditNonWalkable).Enabled = true;
                    view.setStatusText("Change Parameters, Edit Map, or Click Start");
                    view.buttonEditStartUpdate(nodeEditBackColor, nodeEditForeColor, "S", true);
                    view.buttonEditFinishUpdate(nodeEditBackColor, nodeEditForeColor, "F", true);
                    break;
                case View.ViewButton.Start:
                    cancelled = false;
                    nodeEditState = NodeEditState.DISABLED;
                    model.getMap().setNodes(Node.Cost.Movement, 0.0);
                    model.getMap().setNodes(Node.Cost.Heuristic, 0.0);
                    model.getMap().setNodes(Node.Cost.Total, 0.0);

                    foreach (Agent agent in model.getAgents())
                    {
                        agent.getMap().setNodes(Node.Cost.Movement, 0.0);
                        agent.getMap().setNodes(Node.Cost.Heuristic, 0.0);
                        agent.getMap().setNodes(Node.Cost.Total, 0.0);
                        agent.getMap().setNodes(Node.Flag.IsWalkable, true);
                        agent.getMap().setNodes(Node.Flag.IsVisible, false);
                        agent.getMap().setNodes(Node.Flag.IsShared, false);
                    }

                    /* update the view */
                    view.setStatusText("");
                    view.getButton(View.ViewButton.Cancel).Enabled = true;
                    view.getButton(View.ViewButton.Start).Enabled = false;
                    view.getButton(View.ViewButton.RandomMap).Enabled = false;
                    view.getButton(View.ViewButton.EmptyMap).Enabled = false;
                    view.controlEnable(false);
                    view.getComboBox(View.ViewComboBox.Visualizations).Enabled = false;

                    DrawingControl.SuspendDrawing(view.getPanelMap());
                    model.Reset(false);
                    DrawingControl.ResumeDrawing(view.getPanelMap());

                    synchronization = new Synchronization(model.getSimulation().get(View.ViewNumericUpDown.NumberOfAgents));

                    /* start the agent background threads */
                    foreach (Agent agent in model.getAgents())
                    {
                        running++;
                        agent.setNode(Agent.NodeType.Current, agent.getNode(Agent.NodeType.Start));
                        agent.setNode(Agent.NodeType.Target, agent.getNode(Agent.NodeType.Finish));
                        agent.getMap().setNodes(Node.Flag.IsPath, false);
                        agent.getNode(Agent.NodeType.Start).setFlag(Node.Flag.IsWalkable, true);
                        agent.getNode(Agent.NodeType.Finish).setFlag(Node.Flag.IsWalkable, true);
                        BackgroundWorker bgw = new BackgroundWorker();
                        bgw.WorkerSupportsCancellation = true;
                        bgw.DoWork += new DoWorkEventHandler(Start_DoWork);
                        bgw.RunWorkerCompleted += new RunWorkerCompletedEventHandler(Start_RunWorkerCompleted);
                        bgw.RunWorkerAsync(agent);
                        workers.Add(bgw);
                    }

                    /* init the parameters for un-applied map changes */
                    view.getNumericUpDown(View.ViewNumericUpDown.MapSize).Value = model.getSimulation().get(View.ViewNumericUpDown.MapSize);
                    view.getNumericUpDown(View.ViewNumericUpDown.PercentWalkable).Value = model.getSimulation().get(View.ViewNumericUpDown.PercentWalkable);
                    view.getNumericUpDown(View.ViewNumericUpDown.NumberOfAgents).Value = model.getSimulation().get(View.ViewNumericUpDown.NumberOfAgents);
                    break;
                case View.ViewButton.Cancel:
                    cancelled = true;
                    view.getButton(View.ViewButton.Cancel).Enabled = false;
                    view.getButton(View.ViewButton.Start).Enabled = true;
                    view.getButton(View.ViewButton.RandomMap).Enabled = true;
                    view.getButton(View.ViewButton.EmptyMap).Enabled = true;
                    view.controlEnable(true);
                    foreach (BackgroundWorker bgw in workers) { bgw.CancelAsync(); }
                    break;
                case View.ViewButton.ExportCsv:
                    StringBuilder result = new StringBuilder();
                    SaveFileDialog saveFileDialog = new SaveFileDialog();
                    saveFileDialog.Filter = "*.csv|";
                    saveFileDialog.OverwritePrompt = true;

                    if (saveFileDialog.ShowDialog() == DialogResult.OK && saveFileDialog.FileName != null)
                    {
                        ListView listView = view.getSimulationListView();

                        /* export the column headers */
                        foreach (ColumnHeader ch in listView.Columns)
                            result.Append(ch.Text + ",");
                        result.AppendLine();

                        /* export the data rows */
                        foreach (ListViewItem listItem in listView.Items)
                        {
                            foreach (ListViewItem.ListViewSubItem lvs in listItem.SubItems)
                                result.Append(lvs.Text + ",");
                            result.AppendLine();
                        }

                        try
                        {
                            File.WriteAllText(saveFileDialog.FileName + ".csv", result.ToString());
                        }
                        catch (Exception ex)
                        {
                            MessageBox.Show(ex.Message, "CSV Export Error!", MessageBoxButtons.OK, MessageBoxIcon.Error);
                        }
                    }
                    break;
                case View.ViewButton.ClearResults:
                    model.getResults().clear();
                    break;
            }
        }
コード例 #59
0
        private void GetComputerMoveAsynchronously()
        {
            BackgroundWorker AIbackgroundWorker = new BackgroundWorker();
            // define the event handlers
            AIbackgroundWorker.DoWork += (sender, args) =>
            {
                //Console.WriteLine("Started AI thread.");
                int winner = gameBrain.CheckForWin();
                if (winner != 0 || !gameBrain.MakeComputerMove())
                {
                    //Console.WriteLine("Cancelled AI thread.");
                    AIbackgroundWorker.CancelAsync();
                    if (winner != 0)
                        ShowWinner(winner);
                }
            };
            AIbackgroundWorker.RunWorkerCompleted += (sender, args) =>
            {
                if (args.Error != null)  // if an exception occurred during DoWork,
                {
                    //Console.WriteLine("Something went wrong with AI thread.");
                    MessageBox.Show(args.Error.ToString());  // do your error handling here
                }

                //Console.WriteLine("Good with AI thread.");
                int winner = gameBrain.CheckForWin();

                if (winner == 0)
                {
                    TranslateTransform translate = new TranslateTransform();
                    DoubleAnimation enter;
                    Point targetPoint;
                    //userMadeRotation = false;
                    var element = gameBrain.GetComputerMove();
                    Rectangle rec = rectangleChildren.ElementAt(gameBrain.GetComputerMove());
                    targetPoint = rec.TranslatePoint(new Point(rec.ActualWidth, 0), Board);
                    if (gameBrain.isPlayer1Turn())
                    {
                        fireDragon = true;
                        int computerRow = gameBrain.GetComputerMove() / 6;
                        currentDragon = fireDragonEntryImages[computerRow];
                        currentDragon.RenderTransform = translate;
                        currentDragon.Visibility = Visibility.Visible;
                        enter = new DoubleAnimation(0, GetFireAnimationDestination(element, targetPoint), TimeSpan.FromSeconds(1));
                    }
                    else
                    {
                        fireDragon = false;
                        int computerRow = gameBrain.GetComputerMove() / 6;
                        currentDragon = iceDragonEntryImages[computerRow];
                        currentDragon.RenderTransform = translate;
                        currentDragon.Visibility = Visibility.Visible;
                        enter = new DoubleAnimation(0, -GetIceAnimationDestination(element), TimeSpan.FromSeconds(1));
                    }
                    enter.Completed += new EventHandler(OnAnimationEnterComputerCompletition);
                    isAnimationEnterExecuting = true;
                    translate.BeginAnimation(TranslateTransform.XProperty, enter);
                }
                else if (winner != 0)
                {
                    RePaintBoard();
                    ShowWinner(winner);
                }

            };
            AIbackgroundWorker.RunWorkerAsync();
        }
コード例 #60
0
ファイル: Document.cs プロジェクト: DeSciL/Ogama
    /// <summary>
    /// Creates OgamaDataSet and fills it with data from SQL Databasefile 
    /// given bei <see cref="Properties.ExperimentSettings.DatabaseConnectionString"/>.
    /// </summary>
    /// <param name="splash">The loading document splash screens background worker,
    /// needed for interrupting splash when SQL connection fails.</param>
    /// <returns><strong>True</strong>,if successful, otherwise
    /// <strong>false</strong>.</returns>
    public bool LoadSQLData(BackgroundWorker splash)
    {
      // Creates new DataSet
      this.dataSet = new SQLiteOgamaDataSet();

      // Data Source=C:\Users\Adrian\Documents\OgamaExperiments\SlideshowDemo\Database\SlideshowDemo.sdf;Max Database Size=4091
      //bool automaticCorrectMachineNameTried = false;
      //bool automaticResetConnectionTried = false;
      //bool logRebuild = false;

      if (!File.Exists(this.experimentSettings.DatabaseSQLiteFile))
      {
        var result = InformationDialog.Show(
          "Upgrade Database",
          "We need to convert the SQL Database to SQLite. Otherwise Ogama will not be able to open the data. Please confirm the conversion process",
          true,
          MessageBoxIcon.Question);
        switch (result)
        {
          case DialogResult.Cancel:
            return false;
          case DialogResult.Yes:
            // Show loading splash screen if it is not running
            var bgwConvert = new BackgroundWorker();
            bgwConvert.DoWork += this.bgwConvert_DoWork;
            bgwConvert.WorkerSupportsCancellation = true;
            bgwConvert.RunWorkerAsync();

            // Remove the log, cause it may disable the conversion process
            // if it comes from another storage location
            if (File.Exists(this.experimentSettings.DatabaseLDFFile))
            {
              File.Delete(this.experimentSettings.DatabaseLDFFile);
            }

            this.ConvertToSQLiteDatabase();

            bgwConvert.CancelAsync();

            InformationDialog.Show(
              "Conversion done.",
              "The database was converted to sqlite format. The original source was not removed.",
              false,
              MessageBoxIcon.Information);
            break;
          case DialogResult.No:
            break;
        }
      }

      // Check for existing database
      if (!File.Exists(this.experimentSettings.DatabaseSQLiteFile))
      {
        string message = "The experiments database: " + Environment.NewLine +
          this.experimentSettings.DatabaseSQLiteFile + Environment.NewLine +
          "does not exist. This error could not be automically resolved." +
          Environment.NewLine + "Please move the database to the above location, " +
          "or create a new experiment.";
        ExceptionMethods.ProcessErrorMessage(message);
        return false;
      }


      // Show loading splash screen if it is not running
      if (splash != null && !splash.IsBusy)
      {
        splash.RunWorkerAsync();
      }

      //  SqlConnection connectionString = new SqlConnection(Document.ActiveDocument.ExperimentSettings.ServerConnectionString);
      //  ServerConnection connection = new ServerConnection(connectionString);
      //  Server sqlServer = new Server(connection);
      //Attach:
      //  try
      //  {
      //    StringCollection sc = new StringCollection();
      //    sc.Add(Document.ActiveDocument.ExperimentSettings.DatabaseMDFFile);
      //    if (logRebuild)
      //    {
      //      if (File.Exists(Document.ActiveDocument.ExperimentSettings.DatabaseLDFFile))
      //      {
      //        File.Delete(Document.ActiveDocument.ExperimentSettings.DatabaseLDFFile);
      //      }
      //    }
      //    else
      //    {
      //      sc.Add(Document.ActiveDocument.ExperimentSettings.DatabaseLDFFile);
      //    }

      //    // Attach database file
      //    if (!sqlServer.Databases.Contains(Document.ActiveDocument.ExperimentSettings.Name))
      //    {
      //      sqlServer.AttachDatabase(
      //        Document.ActiveDocument.ExperimentSettings.Name,
      //        sc,
      //        logRebuild ? AttachOptions.RebuildLog : AttachOptions.None);
      //    }

      //    sqlServer.ConnectionContext.Disconnect();
      //    logRebuild = false;
      //  }
      //  catch (Exception ex)
      //  {
      //    // Check for the SQLError 9004, which indicates a failure 
      //    // in the log file, which can be fixed by rebuilding the log.
      //    if (ex.InnerException != null)
      //    {
      //      if (ex.InnerException.InnerException != null)
      //      {
      //        if (ex.InnerException.InnerException is SqlException)
      //        {
      //          if (((SqlException)ex.InnerException.InnerException).Number == 9004)
      //          {
      //            logRebuild = true;
      //          }
      //        }
      //      }
      //    }

      //    if (!logRebuild)
      //    {
      //      string message = @"The following error occured: " + ex.Message + Environment.NewLine + Environment.NewLine +
      //        @"If it is the following: 'Failed to generate a user instance of SQL Server due to a failure in starting the process for the user instance. The connection will be closed.'" +
      //        @"Please delete the folder 'Local Settings\Application Data\Microsoft\Microsoft SQL Server Data\" + Document.ActiveDocument.ExperimentSettings.SqlInstanceName +
      //        "' in WinXP or " +
      //        @"'AppData\Local\Microsoft\Microsoft SQL Server Data\" + Document.ActiveDocument.ExperimentSettings.SqlInstanceName + "' on Vista and Windows 7 and try again.";
      //      ExceptionMethods.ProcessMessage("SQL Server connection failed.", message);
      //      ExceptionMethods.ProcessUnhandledException(ex);
      //      if (splash != null && splash.IsBusy)
      //      {
      //        splash.CancelAsync();
      //      }

      //      return false;
      //    }
      //  }

      //  // Go back and rebuild the log file.
      //  if (logRebuild)
      //  {
      //    goto Attach;
      //  }

      // Test connection
      using (var conn = new SQLiteConnection(Document.ActiveDocument.ExperimentSettings.DatabaseConnectionString))
      {
        try
        {
          conn.Open();
        }
        catch (Exception ex)
        {
          //if (splash != null && splash.IsBusy)
          //{
          //  splash.CancelAsync();
          //}

          //if (!automaticResetConnectionTried)
          //{
          //  this.experimentSettings.CustomConnectionString = string.Empty;
          //  this.isModified = true;
          //  automaticResetConnectionTried = true;
          //  goto Test;
          //}

          //if (!automaticCorrectMachineNameTried)
          //{
          //  string currentConnectionString = this.experimentSettings.DatabaseConnectionString;
          //  int firstEqualSign = currentConnectionString.IndexOf('=', 0);
          //  int firstBackslash = currentConnectionString.IndexOf('\\', 0);
          //  string machineName = currentConnectionString.Substring(firstEqualSign + 1, firstBackslash - firstEqualSign - 1);
          //  string currentMachineName = Environment.MachineName;
          //  currentConnectionString = currentConnectionString.Replace(machineName + "\\", currentMachineName + "\\");
          //  this.experimentSettings.CustomConnectionString = currentConnectionString;
          //  automaticCorrectMachineNameTried = true;
          //  this.isModified = true;
          //  goto Test;
          //}

          string message = "Connection to SQLite database failed." + Environment.NewLine +
            "Take a careful look at the database file to attach and its path. " +
            "The .db file should be named the same as the experiment .oga file and located in the "
            + "Database subfolder of the experiment." + Environment.NewLine + "The error message is: "
            + Environment.NewLine + ex.Message + Environment.NewLine;
          ExceptionMethods.ProcessErrorMessage(message);

          //SQLConnectionDialog connectionDialog = new SQLConnectionDialog();
          //connectionDialog.ConnectionString = this.experimentSettings.DatabaseConnectionString;
          //if (connectionDialog.ShowDialog() == DialogResult.OK)
          //{
          //  this.experimentSettings.CustomConnectionString = connectionDialog.ConnectionString;
          //  this.isModified = true;
          //}
          //else
          //{
          //  return false;
          //}

          //goto Test;
        }
        finally
        {
          try
          {
            conn.Close();
          }
          catch (Exception)
          {
          }
        }
      }

      if (splash != null && !splash.IsBusy)
      {
        splash.RunWorkerAsync();
      }

      Application.DoEvents();

      // Loads tables and Data from SQL file into DataSet
      if (this.dataSet.LoadData(splash))
      {
        return true;
      }

      return false;
    }