C# ThreadStart.BeginInvoke方法代码示例

        public void Execute(IWorker[] workers, int runningSecs)
        {
            IAsyncResult[] ar = new IAsyncResult[workers.Length];
              int i = 0;
              foreach (IWorker w in workers) {
            w.WorkerID = i;
            ThreadStart t = new ThreadStart(w.DoWork);
            ar[i++] = t.BeginInvoke(null, null);
              }
              //for (int j = 0; j < runningSecs * 10; j++)
              //{
              //    Console.Write(".");
              //    Thread.Sleep(100);
              //}
              Thread.Sleep(runningSecs * 1000);
              Console.WriteLine();

              foreach (IWorker w in workers) {
            w.Running = false;
              }

              bool timeOut = false;
              foreach (IAsyncResult a in ar) {
              if (!a.IsCompleted)
              {
              if (!a.AsyncWaitHandle.WaitOne(1000))
                  timeOut = true;
              }
              }
              if (timeOut)
              Console.WriteLine("Timed Out!");
        }

		public void Run(string fileName, string arguments)
		{
			if (isRunning) throw new Exception("This ProcessRunner is already running a process.");
			if (!File.Exists(fileName)) throw new FileNotFoundException("The program '"+fileName+"' was not found.",fileName);

			isRunning = true;
			process = new Process();
			process.StartInfo.UseShellExecute = false;
			process.StartInfo.RedirectStandardOutput = true;
			process.StartInfo.RedirectStandardError = true;
			process.StartInfo.CreateNoWindow = true;
			process.StartInfo.FileName = fileName;
			process.StartInfo.Arguments = arguments;
			process.StartInfo.WorkingDirectory = Environment.CurrentDirectory;
			process.Start();
			
			outputReader = process.StandardOutput;
			errorReader = process.StandardError;
			
			// we need to wait for all 3 of our threadpool operations to finish
			// (processexit, readoutput, readerror)
			tasksFinished = 0;
			
			// do our waiting on the threadpool
			ThreadStart waitForExitDel = new ThreadStart(process.WaitForExit);
			waitForExitDel.BeginInvoke(new AsyncCallback(TaskFinished),null);
			
			// also read outputs on the threadpool
			ThreadStart readOutputDel = new ThreadStart(ReadOutput);
			ThreadStart readErrorDel = new ThreadStart(ReadError);
			
			readOutputDel.BeginInvoke(new AsyncCallback(TaskFinished),null);
			readErrorDel.BeginInvoke(new AsyncCallback(TaskFinished),null);
		}

        public void Run(String fileName, String arguments, Boolean shellCommand)
		{
			if (isRunning) throw new Exception("This ProcessRunner is already running a process.");
            if (!shellCommand && !File.Exists(fileName)) throw new FileNotFoundException("The program '" + fileName + "' was not found.", fileName);

			isRunning = true;
			process = new Process();
            process.StartInfo.UseShellExecute = false;
            process.StartInfo.RedirectStandardInput = RedirectInput;
			process.StartInfo.RedirectStandardOutput = true;
            process.StartInfo.RedirectStandardError = true;
            process.StartInfo.StandardOutputEncoding = Encoding.Default;
            process.StartInfo.StandardErrorEncoding = Encoding.Default;
			process.StartInfo.CreateNoWindow = true;
			process.StartInfo.FileName = fileName;
			process.StartInfo.Arguments = arguments;
            process.StartInfo.WorkingDirectory = WorkingDirectory ?? PluginBase.MainForm.WorkingDirectory;
			process.Start();
			
			outputReader = process.StandardOutput;
			errorReader = process.StandardError;
			
			// we need to wait for all 3 threadpool operations 
            // to finish (processexit, readoutput, readerror)
			tasksFinished = 0;
			
			ThreadStart waitForExitDel = new ThreadStart(process.WaitForExit);
			waitForExitDel.BeginInvoke(new AsyncCallback(TaskFinished), null);
			
			ThreadStart readOutputDel = new ThreadStart(ReadOutput);
			ThreadStart readErrorDel = new ThreadStart(ReadError);
			
			readOutputDel.BeginInvoke(new AsyncCallback(TaskFinished), null);
			readErrorDel.BeginInvoke(new AsyncCallback(TaskFinished), null);
		}

        /**
        * Runs the specified process
        */ 
		public void Run(String fileName, String arguments)
		{
			this.isRunning = true;
            this.process = new Process();
            this.process.StartInfo.UseShellExecute = false;
            this.process.StartInfo.RedirectStandardOutput = true;
            this.process.StartInfo.RedirectStandardError = true;
            this.process.StartInfo.RedirectStandardInput = true;
            this.process.StartInfo.CreateNoWindow = true;
            this.process.StartInfo.FileName = fileName;
            this.process.StartInfo.Arguments = arguments;
            this.process.StartInfo.WorkingDirectory = Environment.CurrentDirectory;
            this.process.Start();

            this.outputReader = process.StandardOutput;
            this.errorReader = process.StandardError;
			
			// We need to wait for all 3 of our threadpool operations to finish (processexit, readoutput, readerror)
            this.tasksFinished = 0;
			
			// Do our waiting on the threadpool
			ThreadStart waitForExitDel = new ThreadStart(process.WaitForExit);
			waitForExitDel.BeginInvoke(new AsyncCallback(TaskFinished), null);
			
			// Also read outputs on the threadpool
			ThreadStart readOutputDel = new ThreadStart(this.ReadOutput);
            ThreadStart readErrorDel = new ThreadStart(this.ReadError);

            readOutputDel.BeginInvoke(new AsyncCallback(this.TaskFinished), null);
            readErrorDel.BeginInvoke(new AsyncCallback(this.TaskFinished), null);
		}

 public void SingleButton(object sender, EventArgs args)
 {
     //Create new server in new thread
     // load client gameplayscreen
     ThreadStart test = new ThreadStart(serverStart);
     test.BeginInvoke(null, null);
     ScreenManager.AddScreen(new UserInterface.Screens.GamePlayScreen("127.0.0.1", 28000));
 }

        public ThreadedWriter(ILockStrategy lck)
        {
            _started = new ManualResetEvent(false);
            _complete = new ManualResetEvent(false);

            _lck = lck;
            _delegate = HoldLock;
            _async = _delegate.BeginInvoke(null, null);
            if (!_started.WaitOne(1000, false))
            {
                _delegate.EndInvoke(_async);
                Assert.Fail("Unable to acquire lock");
            }
            Assert.IsTrue(_locked);
        }

        public void Execute(IWorker[] workers, int runningSecs)
        {
            IAsyncResult[] ar = new IAsyncResult[workers.Length];
              int i = 0;
              foreach (IWorker w in workers) {
            ThreadStart t = new ThreadStart(w.DoWork);
            ar[i++] = t.BeginInvoke(null, null);
              }
              /*
              for (int j = 0; j < runningSecs*10; j++) {
            Console.Write(".");
            Thread.Sleep(100);
              }*/
              Thread.Sleep(runningSecs * 1000);
              Console.WriteLine("--------------- Time running finished!!!!");

              foreach (IWorker w in workers) {
            w.Running = false;
              }
              foreach (IAsyncResult a in ar) {
            if (!a.IsCompleted) a.AsyncWaitHandle.WaitOne();
              }
        }

 public void Start()
 {
     thread = new ThreadStart(QueryFrame);
     IsRunning = true;
     thread.BeginInvoke(null, null);
 }

        private void LoadFoundstoneXsmlAdds()
        {
            string strPathToLocalCopyOfXmlFile = Path.Combine(MapPath("~/xml/"),"info.xml");
            string strSourceInformation = "";
            try
            {
                string strTest = Session["FoundstoneMaketingMaterial"].ToString();
                if (Session["FoundstoneMaketingMaterial"].ToString()=="")
                {
                    // return;	// comment here to disable this test
                    XPathDocument myXPathDoc;
                    // we are going to start a new thread and give it 500ms to complete (this is thread we open a TCP connection to www.foundstone.com)
                    bAreWeOnline = false;
                    ThreadStart tsAreWeOnline = new ThreadStart(checkIfWeAreOnline);
                    tsAreWeOnline.BeginInvoke(null,null);
                    Thread.Sleep(500);
                    if (bAreWeOnline)				// if the tcp connection was succssfull we are online
                    {
                        //Response.Write("<hr/> We are online <hr/>");
                        myXPathDoc = new XPathDocument(strPathToWebCopyXmlFile);
                        strSourceInformation = "&nbsp;&nbsp;&nbsp;<i>[The information below is up-to-date and was downloaded from the foundstone website]</i><br>";
                    }
                    else
                    {
                        //Response.Write("<hr/> We are NOT online <hr/>");
                        myXPathDoc = new XPathDocument(strPathToLocalCopyOfXmlFile);
                        strSourceInformation = "&nbsp;&nbsp;&nbsp;<i>[ The current computer is not online, so the information below might be out-of-date]</i><br>";
                    }

                    // now that we have a file to work on (either the dynamic from the website of the one local) we can can do the transformation
                    XslTransform myXslTrans = new XslTransform() ;
                    myXslTrans.Load(Path.Combine(MapPath(Gui.pathToXslFolder),"info.xsl"));
                    MemoryStream msXslTrans = new MemoryStream();
                    myXslTrans.Transform(myXPathDoc,null,msXslTrans, new XmlUrlResolver()) ;
                    msXslTrans.Flush();
                    msXslTrans.Position= 0;
                    // after store the transformation in a session variable so that we don't have to do this everytime
                    Session["FoundstoneMaketingMaterial"] =  (new StreamReader(msXslTrans)).ReadToEnd();
                }
                lbXmlInformation.Text = strSourceInformation + Session["FoundstoneMaketingMaterial"].ToString();
            }
            catch (Exception ex)
            {
                Response.Write("<hr/>LoadFoundstoneXsmlAdds: " + ex.Message + "<hr/>");
            }
        }

        public void SetupAsync()
        {
            if (IsBusy) return;

            this.dataGridViewUpdates.Rows.Clear();
            releases = null;
            timerImgAnimate.Start();

            this.Invalidate();
            this.Refresh();

            ThreadStart ts = new ThreadStart(SetupAndBuildReleaseList);
            asyncres = ts.BeginInvoke(new AsyncCallback(SetupAsyncCompleted), null);
        }

        /// <summary>
        /// Fully self contained method that sends email by just sending
        /// without waiting for confirmation by starting a new thread
        /// </summary>
        /// <returns></returns>
        public void SendMailAsync()
        {
            ThreadStart oDelegate = new ThreadStart(SendMailRun);
            //			Thread myThread = new Thread(oDelegate);
            //			myThread.Start();

            /// If you want to use the Thread Pool you can just use a delegate
            /// This will often be faster and more efficient especially for quick operations
            oDelegate.BeginInvoke(null, null);
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            foreach (string name in names)
            {
                ToolStripMenuItem tsi = new ToolStripMenuItem(name);
                tsi.Click += ToolStripMenuItem_Click;
                contextMenuStrip1.Items.Add(tsi);
            }

            if (!File.Exists(strDownloadPath + "\\trainedImages.xml"))
                return;
            string xml = File.ReadAllText(strDownloadPath + "\\trainedImages.xml");
            trainedFaces = (SeDes.ToObj(xml, trainedFaces) as List<trainedFace>);
            ThreadStart ts = new ThreadStart(fixFaces);
            progressBar1.Visible = true;

            IAsyncResult iar = ts.BeginInvoke((AsyncCallback) =>
            {
                this.Invoke((MethodInvoker)delegate
                {
                    progressBar1.Visible = false;
                });
            }, null);
            

        }

 private void cmdBeClient_Click(object sender, System.EventArgs e)
 {
     //***********************  Client Attempt ******************************************
     //amIClient = true;
     cmdFindClients.Enabled = false;
     ThreadStart myThreadStart = new ThreadStart(client);
     System.IAsyncResult m = null;
     m = myThreadStart.BeginInvoke(new AsyncCallback(caller),null);
 }

 private void button1_Click_1(object sender, System.EventArgs e)
 {
     //start a new thread running doServerStuff()
     ThreadStart myThreadStart = new ThreadStart(doServerStuff);
     System.IAsyncResult m = null;
     m = myThreadStart.BeginInvoke(new AsyncCallback(caller),null);
 }

		public void LoadAsync ()
		{
			if (load_completed)
				return;
			ThreadStart async = new ThreadStart (Load);
			async.BeginInvoke (AsyncFinished, async);
		}