C# BackgroundWorker.RunWorkerAsync方法代码示例

 public void bgworkercounter()
 {
     var backgroundWorker1 = new BackgroundWorker();
     backgroundWorker1.DoWork += backgroundWorker1_DoWork;
     backgroundWorker1.RunWorkerCompleted += backgroundWorker1_RunWorkerCompleted;
     backgroundWorker1.RunWorkerAsync();
 }

    // private static SimpleCompileForm _simpleCompileForm;

    private static void Main(string[] args)
    {
        var worker = new BackgroundWorker();
        worker.DoWork += (sender, e) =>
        {
            try
            {
                _nativeWorkbenchForm = new NativeWorkbenchForm();
                _timer = new System.Windows.Forms.Timer();
                _timer.Stop();
                _timer.Interval = 100;
                _timer.Tick += _timer_Tick;
                _timer.Start();
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex);
            }
            Application.EnableVisualStyles();
            Application.Run(_nativeWorkbenchForm);
        };
        worker.RunWorkerAsync();


        Thread.Sleep(-1);
    }

 // Use this for initialization
 void Start()
 {
     // init a background worker thread
     BackgroundWorker worker = new BackgroundWorker();
     worker.DoWork += HandleWorkerDoWork;
     worker.RunWorkerAsync();
 }

    public NativeWorkbench()
    {
        try
        {
          //  KeyDown += OnKeyDown;
            Tick += OnTick;
        }
        catch (Exception e)
        {
            SaveLoad.Log(e.ToString());
           // Debug.WriteLine(e);
        }


        BackgroundWorker myWorker = new BackgroundWorker();
        myWorker.DoWork += (sender, e) =>
        {
            try
            {
                Application.EnableVisualStyles();
                Application.Run(_nativeWorkbenchForm);
            }
            catch (Exception ex)
            {
                SaveLoad.Log(ex.ToString());
            }
        };
        myWorker.RunWorkerAsync();
    }

        public void TestCancelAsync()
        {
            BackgroundWorker bw = new BackgroundWorker();

            bw.DoWork += DoWorkExpectCancel;
            bw.WorkerSupportsCancellation = true;

            manualResetEvent3 = new ManualResetEventSlim(false);

            bw.RunWorkerAsync("Message");
            bw.CancelAsync();

            bool ret = manualResetEvent3.Wait(TimeoutLong);
            Assert.True(ret);
            // there could be race condition between worker thread cancellation and completion which will set the CancellationPending to false 
            // if it is completed already, we don't check cancellation
            if (bw.IsBusy) // not complete
            {
                if (!bw.CancellationPending)
                {
                    for (int i = 0; i < 1000; i++)
                    {
                        Wait(TimeoutShort);
                        if (bw.CancellationPending)
                        {
                            break;
                        }
                    }
                }
                // Check again
                if (bw.IsBusy)
                    Assert.True(bw.CancellationPending, "Cancellation in Main thread");
            }
        }

 public void ThrowExceptionOnCompletedFalse()
 {
     var b = new BackgroundWorker<object, object, object>
                 {
                     ThrowExceptionOnCompleted = false,
                     DoWork = ThrowException
                 };
     b.RunWorkerAsync();
 }

 public Worker(string[] arguments)
 {
     this.worker = new BackgroundWorker();
     worker.WorkerSupportsCancellation = true;
     worker.WorkerReportsProgress = true;
     worker.DoWork += new DoWorkEventHandler(worker_DoWork);
     worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(bw_RunWorkerCompleted);
     worker.RunWorkerAsync(arguments);
 }

 public FFRKMySqlInstance()
 {
     mDatabaseThread = new BackgroundWorker();
     mDatabaseThread.DoWork += mDatabaseThread_DoWork;
     mDatabaseThread.RunWorkerAsync();
     mDatabaseQueue = new BlockingCollection<IDbRequest>();
     mCancellationTokenSource = new CancellationTokenSource();
     mConnectionState = ConnectionState.Disconnected;
 }

 public FileState()
     : base()
 {
     asyncWriter = new BackgroundWorker();
     asyncWriter.DoWork += new DoWorkEventHandler(WriteDataAsync);
     asyncWriter.RunWorkerCompleted +=
             new RunWorkerCompletedEventHandler(
                 (object sender, RunWorkerCompletedEventArgs e) => { if (postponedWrite) { postponedWrite = false; asyncWriter.RunWorkerAsync(); } }
             );
 }

        public void TestBackgroundWorkerBasic()
        {
            var orignal = SynchronizationContext.Current;
            try
            {
                SynchronizationContext.SetSynchronizationContext(null);

                const int expectedResult = 42;
                const int expectedReportCallsCount = 5;
                int actualReportCallsCount = 0;
                var worker = new BackgroundWorker() { WorkerReportsProgress = true };
                var progressBarrier = new Barrier(2, barrier => ++actualReportCallsCount);
                var workerCompletedEvent = new ManualResetEventSlim(false);

                worker.DoWork += (sender, e) =>
                {
                    for (int i = 0; i < expectedReportCallsCount; i++)
                    {
                        worker.ReportProgress(i);
                        progressBarrier.SignalAndWait();
                    }

                    e.Result = expectedResult;
                };
                worker.RunWorkerCompleted += (sender, e) =>
                {
                    try
                    {
                        Assert.Equal(expectedResult, (int)e.Result);
                        Assert.False(worker.IsBusy);
                    }
                    finally
                    {
                        workerCompletedEvent.Set();
                    }
                };
                worker.ProgressChanged += (sender, e) =>
                {
                    progressBarrier.SignalAndWait();
                };

                worker.RunWorkerAsync();

                // wait for singal from WhenRunWorkerCompleted
                Assert.True(workerCompletedEvent.Wait(TimeoutLong));
                Assert.False(worker.IsBusy);
                Assert.Equal(expectedReportCallsCount, actualReportCallsCount);
            }
            finally
            {
                SynchronizationContext.SetSynchronizationContext(orignal);
            }
        }

            public void Run()
            {
                worker = new BackgroundWorker();

                worker.DoWork += new DoWorkEventHandler(DoWork);
                worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(RunWorkerCompleted);
                worker.ProgressChanged += new ProgressChangedEventHandler(ProgressChanged);
                worker.WorkerReportsProgress = true;
                worker.WorkerSupportsCancellation = true;

                worker.RunWorkerAsync(Options);
            }

 void SendTransform()
 {
     var pos = transform.position;
     var angles = transform.localEulerAngles;
     var worker = new BackgroundWorker();
     var time = Time.time;
     worker.DoWork += (sender, e) => {
         ISFSObject obj = NetworkHelper.TransformToSFSObject(pos, angles);
         obj.PutBool("isBlue", IsBlueTeam);
         obj.PutFloat("time", time);
         smartFox.Send(new ObjectMessageRequest(obj));
     };
     worker.RunWorkerAsync();
 }

 void RunInBackgroundOrNot(Action action)
 {
     if (runInSeparateThread) {
         var worker = new BackgroundWorker ();
         worker.DoWork += delegate(object sender, DoWorkEventArgs e) {
             action ();
         };
         worker.RunWorkerCompleted += delegate(object sender, RunWorkerCompletedEventArgs e) {
             Debug.Log ("Background thread done");
         };
         worker.RunWorkerAsync ();
     } else {
         action ();
         Debug.Log ("Done");
     }
 }

 public wireless_devices(AdminWindow w)
 {
     mainform = w;
     AddDevice = new RelayCommand(o => SecuredDevices.Add(o as WirelessDevice), o => (o != null && (SecuredDevices.Count <= 1)));
     RemoveDevice = new RelayCommand(o => SecuredDevices.Remove(o as WirelessDevice), o => o != null);
     InitializeComponent();
     WindowStartupLocation = System.Windows.WindowStartupLocation.CenterScreen;
     //initialiseLoggingFramework();
     log = Logger.Instance;
     bg = new BackgroundWorker();
     bg.DoWork += new DoWorkEventHandler(bg_DoWork);
     bg.RunWorkerCompleted += new RunWorkerCompletedEventHandler(bg_RunWorkerCompleted);
     if (!bg.IsBusy)
     {
         bg.RunWorkerAsync();
     }
 }

        public POSPageViewModel()
        {
            this.SaleCommand = new Telerik.Windows.Controls.DelegateCommand(o => this.methodSaleCommand());

            MyImageButtonCatagories = new ObservableCollection<MyImageButtonCatagory>();

            BackgroundWorker imageButtonsCataogryWorker = new BackgroundWorker();
            imageButtonsCataogryWorker.DoWork += new DoWorkEventHandler(imageButtonsCatagoryWorker_DoWork);
            imageButtonsCataogryWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(imageButtonsCatagoryWorker_runworkercompleted);
            imageButtonsCataogryWorker.RunWorkerAsync();

            this._eventAggregator.GetEvent<AmountEnteredEvent>()
               .Subscribe((eventDetail) =>
               {
                   logger.Trace("event received {0}", eventDetail.Id);
                   userEnterAmount(double.Parse(eventDetail.Detail));
               });
        }