BackgroundWorker使用方法

最新推荐文章于 2022-08-19 15:47:19 发布
最新推荐文章于 2022-08-19 15:47:19 发布
阅读量116 收藏
点赞数
原文链接：http://www.cnblogs.com/tomclock/p/7063047.html
版权

这里先给出几个连接‘

https://stackoverflow.com/questions/1862590/how-to-update-gui-with-backgroundworker 

http://www.dotnetframework.org/default.aspx/DotNET/DotNET/8@0/untmp/whidbey/REDBITS/ndp/fx/src/CompMod/System/ComponentModel/BackgroundWorker@cs/1/BackgroundWorker@cs 

https://www.codeproject.com/Articles/42103/Generic-Background-Worker 

 https://msdn.microsoft.com/ja-jp/library/system.componentmodel.backgroundworker(v=vs.110).aspx

原代码：

namespace System.ComponentModel
{
     using System.ComponentModel.Design.Serialization;
     using System.Diagnostics;
     using System.Security.Permissions;
     using System.Threading;
  
     [
         SRDescription(SR.BackgroundWorker_Desc),
         DefaultEvent( "DoWork" ),
         HostProtection(SharedState = true )
     ]
     public class BackgroundWorker : Component
     {
         // Private statics
         private static readonly object doWorkKey = new object ();
         private static readonly object runWorkerCompletedKey = new object ();
         private static readonly object progressChangedKey = new object ();
  
         // Private instance members
         private bool                                canCancelWorker = false ;
         private bool                                workerReportsProgress = false ;
         private bool                                cancellationPending = false ;
         private bool                                isRunning = false ;
         private AsyncOperation                      asyncOperation = null ;
         private readonly WorkerThreadStartDelegate  threadStart;
         private readonly SendOrPostCallback operationCompleted;
         private readonly SendOrPostCallback progressReporter;
 
         public BackgroundWorker()
         {
             threadStart        = new WorkerThreadStartDelegate(WorkerThreadStart);
             operationCompleted = new SendOrPostCallback(AsyncOperationCompleted);
             progressReporter   = new SendOrPostCallback(ProgressReporter);
         }
  
         private void AsyncOperationCompleted( object arg)
         {
             isRunning = false ;
             cancellationPending = false ;
             OnRunWorkerCompleted((RunWorkerCompletedEventArgs)arg);
         }
  
         [
           Browsable( false ),
           SRDescription(SR.BackgroundWorker_CancellationPending)
         ]
         public bool CancellationPending
         {
             get { return cancellationPending; }
         }
  
         public void CancelAsync()
         {
             if (!WorkerSupportsCancellation)
             {
                 throw new InvalidOperationException(SR.GetString(SR.BackgroundWorker_WorkerDoesntSupportCancellation));
             }
 
             cancellationPending = true ;
         }
 
         [
           SRCategory(SR.PropertyCategoryAsynchronous),
           SRDescription(SR.BackgroundWorker_DoWork)
         ]
         public event DoWorkEventHandler DoWork
         {
             add
             {
                 this .Events.AddHandler(doWorkKey, value);
             }
             remove
             {
                 this .Events.RemoveHandler(doWorkKey, value);
             }
         }
 
         /// <include file="doc\BackgroundWorker.uex" path="docs/doc[@for="BackgroundWorker.IsBusy"]/*">
         [
           Browsable( false ),
           SRDescription(SR.BackgroundWorker_IsBusy)
         ]
         public bool IsBusy
         {
             get
             {
                 return isRunning;
             }
         }
  
         /// <include file="doc\BackgroundWorker.uex" path="docs/doc[@for="BackgroundWorker.OnDoWork"]/*">
         protected virtual void OnDoWork(DoWorkEventArgs e)
         {
             DoWorkEventHandler handler = (DoWorkEventHandler)(Events[doWorkKey]);
             if (handler != null )
             {
                 handler( this , e);
             }
         }
 
         /// <include file="doc\BackgroundWorker.uex" path="docs/doc[@for="BackgroundWorker.OnRunWorkerCompleted"]/*">
         protected virtual void OnRunWorkerCompleted(RunWorkerCompletedEventArgs e)
         {
             RunWorkerCompletedEventHandler handler = (RunWorkerCompletedEventHandler)(Events[runWorkerCompletedKey]);
             if (handler != null )
             {
                 handler( this , e);
             }
         }
  
         protected virtual void OnProgressChanged(ProgressChangedEventArgs e)
         {
             ProgressChangedEventHandler handler = (ProgressChangedEventHandler)(Events[progressChangedKey]);
             if (handler != null )
             {
                 handler( this , e);
             }
         }
  
         [
           SRCategory(SR.PropertyCategoryAsynchronous),
           SRDescription(SR.BackgroundWorker_ProgressChanged)
         ]
         public event ProgressChangedEventHandler ProgressChanged
         {
             add
             {
                 this .Events.AddHandler(progressChangedKey, value);
             }
             remove
             {
                 this .Events.RemoveHandler(progressChangedKey, value);
             }
         }
  
         // Gets invoked through the AsyncOperation on the proper thread.
         private void ProgressReporter( object arg)
         {
             OnProgressChanged((ProgressChangedEventArgs)arg);
         }
  
         // Cause progress update to be posted through current AsyncOperation.
         public void ReportProgress( int percentProgress)
         {
             ReportProgress(percentProgress, null );
         }
 
         // Cause progress update to be posted through current AsyncOperation.
         public void ReportProgress( int percentProgress, object userState)
         {
             if (!WorkerReportsProgress)
             {
                 throw new InvalidOperationException(SR.GetString(SR.BackgroundWorker_WorkerDoesntReportProgress));
             }
  
             ProgressChangedEventArgs args = new ProgressChangedEventArgs(percentProgress, userState);
 
             if (asyncOperation != null )
             {
                 asyncOperation.Post(progressReporter, args);
             }
             else
             {
                 progressReporter(args);
             }
         }
 
         public void RunWorkerAsync()
         {
             RunWorkerAsync( null );
         }
 
         public void RunWorkerAsync( object argument)
         {
             if (isRunning)
             {
                 throw new InvalidOperationException(SR.GetString(SR.BackgroundWorker_WorkerAlreadyRunning));
             }
  
             isRunning = true ;
             cancellationPending = false ;
  
             asyncOperation = AsyncOperationManager.CreateOperation( null );
             threadStart.BeginInvoke(argument,
                                     null ,
                                     null );
         }
  
         [
           SRCategory(SR.PropertyCategoryAsynchronous),
           SRDescription(SR.BackgroundWorker_RunWorkerCompleted)
         ]
         public event RunWorkerCompletedEventHandler RunWorkerCompleted
         {
             add
             {
                 this .Events.AddHandler(runWorkerCompletedKey, value);
             }
             remove
             {
                 this .Events.RemoveHandler(runWorkerCompletedKey, value);
             }
         }
  
         [ SRCategory(SR.PropertyCategoryAsynchronous),
           SRDescription(SR.BackgroundWorker_WorkerReportsProgress),
           DefaultValue( false )
         ]
         public bool WorkerReportsProgress
         {
             get { return workerReportsProgress; }
             set { workerReportsProgress = value; }
         }
 
         [
           SRCategory(SR.PropertyCategoryAsynchronous),
           SRDescription(SR.BackgroundWorker_WorkerSupportsCancellation),
           DefaultValue( false )
         ]
         public bool WorkerSupportsCancellation
         {
             get { return canCancelWorker; }
             set { canCancelWorker = value; }
         }
  
         private delegate void WorkerThreadStartDelegate( object argument);
  
         private void WorkerThreadStart( object argument)
         {
             object workerResult = null ;
             Exception error = null ;
             bool cancelled = false ;
  
             try
             {
                 DoWorkEventArgs doWorkArgs = new DoWorkEventArgs(argument);
                 OnDoWork(doWorkArgs);
                 if (doWorkArgs.Cancel)
                 {
                     cancelled = true ;
                 }
                 else
                 {
                     workerResult = doWorkArgs.Result;
                 }
             }
             catch (Exception exception)
             {
                 error = exception;
             }
  
             RunWorkerCompletedEventArgs e =
                 new RunWorkerCompletedEventArgs(workerResult, error, cancelled);
  
             asyncOperation.PostOperationCompleted(operationCompleted, e);
         }
 
     }
}
 

 

转载于:https://www.cnblogs.com/tomclock/p/7063047.html

1361976860
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
关于backgroundworker的使用方法
11-11
使用backgroundwork创建的一个有关进度条的小程序，包含代码，
c# BackgroundWorker使用方法
08-19
C# BackgroundWorker 使用方法 C# BackgroundWorker 是一个非常有用的组件，可以帮助开发者在 Windows 窗体应用程序中执行耗时的操作，避免了界面的冻结和卡顿。下面将详细介绍 C# BackgroundWorker 的使用方法。 ...
c# BackgroundWorker控件使用方法
拓
07-08 2040
在使用之前先了解一些知识。 1、BackgroundWorker作用：     主要用在单独的线程上执行操作。 BackgroundWorker类允许您在单独的专用线程上运行操作。耗时的操作（如下载和数据库事务）在长时间运行时可能会导致用户界面(UI) 似乎处于停止响应状态。如果
BackGroundWorker用法
weixin_30912051的博客
12-02 69
在编程中经常会遇到在一个按钮中执行复杂操作，并将复杂操作最后返回的值加入一个ListView或ComboBox中候选。这个时候程序会卡，当程序员将这些卡代码放进线程(Thread)中后发现当对控件操作时出现“线程间操作无效: 从不是创建控件的线程访问它”异常。 为什么.net不让我们跨线程操作控件，这是有好处的。因为如果你的线程多了，那么当两个线程同时尝试将一个控件变...
C#　BackgroundWorker的用法
qq_25744257的博客
11-29 1120
BackgroundWorker是.NET Framework 里用来执行多线程任务的控件，它允许开发人员在一个单独的线程上执行一些操作。耗时的操作（如下载和数据库事务）在长时间运行时可能会导致用户界面 (UI) 始终处于停止响应状态。如果您需要能进行响应的用户界面，而且面临与这类操作相关的长时间延迟，则可以使用 BackgroundWorker 类方便地解决问题。 若要在后台执行耗时的操作，请...
C# BackgroundWorker使用教程
08-26
在执行异步操作时，可以使用RunWorkerAsync方法开始执行一个后台操作，该方法将触发BackgroundWorker.DoWork事件，并以异步的方式执行DoWork事件中的代码。例如： bgWorker.RunWorkerAsync("hello"); 在DoWork事件...
BackgroundWorker c#使用方法
03-29
在本篇内容中，我们将深入探讨`BackgroundWorker`的使用方法，以及如何结合`ProgressBar`来提供用户反馈。 首先，我们需要了解`BackgroundWorker`的基本原理。`BackgroundWorker`类提供了异步执行操作的能力，这...
backgroundworker的使用方法
06-19
本篇文章将详细介绍如何使用BackgroundWorker，以及它在多线程编程中的重要性。 首先，理解背景工作原理是至关重要的。在Windows应用程序中，主线程通常负责显示和交互UI，而当此线程被长时间运行的任务阻塞时，...
C# BackGroundWorker 的简单使用
思月行云
06-23 3983
<br /> <br />在 WinForms 中，有时要执行耗时的操作，在该操作未完成之前操作用户界面，会导致用户界面停止响应。<br />解决的方法就是新开一个线程，把耗时的操作放到线程中执行，这样就可以在用户界面上进行其它操作。<br />新建线程可以用 Thread 类，可以实现多线程同时操作，简单的可以通过 BackgroundWorker 类实现。<br /><br />用 BackgroundWorker 类执行耗时的操作<br />BackgroundWorker 类在 System.Com
background-eraser:使用精确的抗锯齿消除图像的简单背景
05-18
背景擦除器 使用精确的抗锯齿消除图像的背景。
BackgroundWorker的用法
weixin_40645998的博客
10-27 518
C#在后台运行操作：BackgroundWorker的用法 在我们的程序中，经常会有一些耗时较长的运算，为了保证用户体验，不引起界面不响应，我们一般会采用多线程操作，让耗时操作在后台完成，完成后再进行处理或给出提示，在运行中，也会时时去刷新界面上的进度条等显示，必要时还要控制后台线程中断当前操作。 以前，类似的应用会比较麻烦，需要写的代码较多，也很容易出现异常。在.net中，提供了一个组件BackgroundWorker就是专门解决这个问题的。BackgroundWorker类允许在单独的专用线程上运行操作
C# BackgroundWorker使用总结
路的博客
11-24 298
using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; namespace CSharper开发实例 { public partial class Frm_BackgroundW...
BackgroundWorker的使用
Adele的专栏
11-26 590
本文简单介绍下BackgroundWorker及使用方法举例。 1.介绍 BackGroundWorker是微软提供的封装好了的，常用于在后台开启一个线程执行耗时操作，避免UI线程不响应。 BackgroundWorker使用起来很方便，直接从工具箱中拖拽一个控件到Winfrom窗体即可。控件拖到窗体上后，点击该控件，打开属性窗口的事件，可以看到该控件只有三个事件方法。  Backgro...
BackgroundWorker使用
weixin_42103688的博客
08-19 189
backgroundworker
C# BackgroundWorker用法详解（源码可直接使用）
IT技术猿猴的博客
05-27 650
在C#程序中，经常会有一些耗时较长的CPU密集型运算，如果直接在 UI 线程执行这样的运算就会出现UI不响应的问题。解决这类问题的主要途径是使用多线程，启动一个后台线程，把运算操作放在这个后台线程中完成。但是原生接口的线程操作有一些难度，如果要更进一步的去完成线程间的通信就会难上加难。 还好 .NET 类库中提供了一个叫做 BackgroundWorker 的类可以比较优雅的解决这类问题。虽然BackgroundWorker 类使用起来比较简单，但其中还是有一些需要注意的细节，下面我们就通过 demo..
C#中BackgroundWorker的最简单用法
cczz598的专栏
09-28 937
C#使用不太多，但是总是要用上线程，比如后台跑个什么函数，让程序不要卡死之类的，以前总
【C#】BackgroundWorker类传递参数
weixin_34268310的博客
02-15 1048
要传递多个不同类型的参数： private void Test(){ int a = 123; string b = "456"; bool c = true; BackgroundWorker worker = new BackgroundWorker(); worker.DoWork += (o, ea) =&gt; { Wo...
详解 backgroundworker类
飞鹰的专栏
12-15 1686
  backgroundworker类 收藏 前段时间用到了backgroundworker类做了一个简单的读取后台数据到界面datagridview中的程序，今天又用到了这个类，碰到了些问题，这里总结下:概述：BackgroundWorker 类允许您在单独的专用线程上运行操作。耗时的操作（如下载和数据库事务）在长时间运行时可能会导致用户界面 (UI) 似乎处于停止响应状态。如果您需要能
backgroundWorker的使用方法
最新发布
05-23
以下是使用BackgroundWorker的步骤： 1. 在Visual Studio中拖动一个BackgroundWorker组件到窗体或控件中。 2. 设置BackgroundWorker的属性，包括是否支持取消操作、是否报告进度等。 3. 在代码中为DoWork事件编写...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值