日韩无码专区无码一级三级片|91人人爱网站中日韩无码电影|厨房大战丰满熟妇|AV高清无码在线免费观看|另类AV日韩少妇熟女|中文日本大黄一级黄色片|色情在线视频免费|亚洲成人特黄a片|黄片wwwav色图欧美|欧亚乱色一区二区三区

RELATEED CONSULTING
相關咨詢
選擇下列產品馬上在線溝通
服務時間：8:30-17:00
你可能遇到了下面的問題
關閉右側工具欄

新聞中心

這里有您想知道的互聯(lián)網(wǎng)營銷解決方案
【C#】分享帶等待窗體的任務執(zhí)行器一枚

適用環(huán)境：.net 2.0+的Winform項目。

創(chuàng)新互聯(lián)公司專注于企業(yè)全網(wǎng)營銷推廣、網(wǎng)站重做改版、民樂網(wǎng)站定制設計、自適應品牌網(wǎng)站建設、HTML5、商城網(wǎng)站開發(fā)、集團公司官網(wǎng)建設、成都外貿網(wǎng)站建設公司、高端網(wǎng)站制作、響應式網(wǎng)頁設計等建站業(yè)務，價格優(yōu)惠性價比高，為民樂等各大城市提供網(wǎng)站開發(fā)制作服務。

先解釋一下我所謂的【帶等待窗體的任務執(zhí)行器】是個什么鬼，就是可以用該類執(zhí)行任意耗時方法（下文將把被執(zhí)行的方法稱為任務或任務方法），執(zhí)行期間會顯示一個模式等待窗體，讓用戶知道任務正在得到執(zhí)行，程序并沒有卡死。先看一下效果：

功能：

等待窗體可以使用執(zhí)行器自帶的默認窗體（就上圖的樣子），嫌丑你也可以使用自己精心設計的窗體，甚至基于Devexpress、C1等第三方漂亮窗體打造也是完全可以的
在任務中可以更新等待窗體上的Label、ProgressBar之類的控件以提供進度反饋。懶得反饋的話，就默認“請稍候...”+Marquee式滾動
如果任務允許被終止，用戶可以通過某些操作終止任務執(zhí)行（例如點擊上圖中的【取消】按鈕）；如果不允許，你可以把取消按鈕隱藏了，或者在任務中不響應用戶的終止請求就好
任務的執(zhí)行結果（包括ref/out參數(shù)）、是否出現(xiàn)異常、是否被取消等情況都可以得到

原理：

調用任務所屬委托的BeginInvoke，讓任務在后臺線程執(zhí)行，隨即在UI線程（通常就是主線程）調用等待窗體的ShowDialog彈出模式窗體，讓用戶知道任務正在執(zhí)行的同時阻止用戶進行其他操作。由于任務和等待窗體分別在不同的線程跑，所以等待窗體不會被卡住

任務執(zhí)行期間可以通過執(zhí)行器提供的一組屬性和方法操作等待窗體上的控件，這組屬性和方法內部是通過調用等待窗體的Invoke或BeginInovke對控件進行操作，實現(xiàn)跨線程訪問控件
任務執(zhí)行期間用戶可以通過點擊等待窗體上的【取消】按鈕（如果你讓它顯示的話）或點擊右上角關閉按鈕發(fā)出終止任務的請求（等待窗體會攔截關閉操 作），其結果是執(zhí)行器的UserCancelling屬性會置為true，所以在任務中可以訪問該屬性得知用戶是否請求了取消操作，如果你同意終止的話， 需設置執(zhí)行器的Cancelled=true，并隨即return出任務方法

任務執(zhí)行完后（無論成功、異常、取消）會自動進入異步回調方法，回調方法中會首先訪問Cancelled獲知任務是否已取消，如果已取消，則直接 return出回調方法；如果未取消，則調用任務所屬委托的EndInvoke得到任務執(zhí)行結果或異常。最后不管取消與否，finally塊中會設置等待 窗體的DialogResult屬性，以確保關閉等待窗體

等待窗體關閉后，執(zhí)行器會繼續(xù)執(zhí)行ShowDialog后面的語句。如果任務已取消，則拋出特定異常報告調用者；如果任務存在異常，則拋出該異常；以上情況都不存在的話，返回任務結果

如述，功能簡單，實現(xiàn)容易，我只是把這種需求通用化了一下，讓還沒有類似輪子的朋友可以拿去就用。另外還有個基于BackgroundWorker的實現(xiàn)方式，我可能會在下一篇文章分享。

先看一下大致的使用示例：

 
 
    
  
  
  1. //WaitUI就是執(zhí)行器 
    2. 
  
  
  2. private void button1_Click(object sender, EventArgs es) 
    3. 
  
  
  3. { 
    4. 
  
  
  4.     //可檢測執(zhí)行器是否正在執(zhí)行另一個任務。其實基本不可能出現(xiàn)IsBusy=true，因為執(zhí)行器工作時，用戶做不了其它事 
    5. 
  
  
  5.     //老實說這個IsBusy要不要公開我還糾結了一下，因為公開了沒什么用，但也沒什么壞處，因為setter是private的 
    6. 
  
  
  6.     //Whatever~最后我還是選擇公開，可能~因為愛情 
    7. 
  
  
  7.     //if (WaitUI.IsBusy) { return; } 
    8. 
  
  
  8.  
    9. 
  
  
  9.     try 
    10. 
  
  
  10.     { 
    11. 
  
  
  11.         //WaitUI.RunXXX方法用于執(zhí)行任務 
    12. 
  
  
  12.         //該方法的返回值就是任務的返回值 
    13. 
  
  
  13.         //任務拋出的異常會通過RunXXX方法拋出 
    14. 
  
  
  14.  
    15. 
  
  
  15.         //WaitUI.RunAction(Foo, 33, 66);                                      //執(zhí)行無返回值的方法 
    16. 
  
  
  16.         int r = WaitUI.RunFunc(Foo, 33, 66);                                  //執(zhí)行有返回值的方法 
    17. 
  
  
  17.         //object r = WaitUI.RunDelegate(new Func(Foo), 33, 66);//執(zhí)行委托 
    18. 
  
  
  18.         //WaitUI.RunAction(new MyWaitForm(), Foo);//指定自定義等待窗體執(zhí)行任務，幾個RunXXX方法都有可指定自定義窗體的重載 
    19. 
  
  
  19.  
    20. 
  
  
  20.         MessageBoxEx.Show("任務完成。" + r); 
    21. 
  
  
  21.     } 
    22. 
  
  
  22.     catch (WorkCancelledException)//任務被取消是通過拋出該異常來報告 
    23. 
  
  
  23.     { 
    24. 
  
  
  24.         MessageBoxEx.Show("任務已取消！"); 
    25. 
  
  
  25.     } 
    26. 
  
  
  26.     catch (Exception ex)//任務拋出的異常 
    27. 
  
  
  27.     { 
    28. 
  
  
  28.         MessageBoxEx.Show("任務出現(xiàn)異常！" + ex.Message); 
    29. 
  
  
  29.     } 
    30. 
  
  
  30. } 
    31. 
  
  
  31.  
    32. 
  
  
  32. //耗時任務。因為該方法會在后臺線程執(zhí)行，所以方法中不可以有訪問控件的代碼 
    33. 
  
  
  33. int Foo(int a, int b) 
    34. 
  
  
  34. { 
    35. 
  
  
  35.     //可以通過執(zhí)行器的一系列公開屬性和方法間接操作等待窗體的UI元素 
    36. 
  
  
  36.     WaitUI.CancelControlVisible = true;//設置取消任務的控件的可見性，即是否允許用戶取消任務（默認是false：不可見） 
    37. 
  
  
  37.     WaitUI.BarStyle = ProgressBarStyle.Continuous;//設置滾動條樣式（默認是Marquee：循環(huán)梭動式） 
    38. 
  
  
  38.     WaitUI.BarMaximum = 100;      //設置滾動條值上限（默認是100） 
    39. 
  
  
  39.     WaitUI.BarMinimum = 0;        //設置滾動條值下限（默認是0） 
    40. 
  
  
  40.     WaitUI.BarStep = 1;           //設置滾動條步進幅度（默認是10） 
    41. 
  
  
  41.     WaitUI.BarVisible = true;     //設置滾動條是否可見（默認是true：可見） 
    42. 
  
  
  42.  
    43. 
  
  
  43.     int i; 
    44. 
  
  
  44.     for (i = a; i < b; i++) 
    45. 
  
  
  45.     { 
    46. 
  
  
  46.         if (WaitUI.UserCancelling)//響應用戶的取消請求 
    47. 
  
  
  47.         { 
    48. 
  
  
  48.             WaitUI.Cancelled = true;//告訴執(zhí)行器任務已取消 
    49. 
  
  
  49.             return 0; 
    50. 
  
  
  50.         } 
    51. 
  
  
  51.  
    52. 
  
  
  52.         //可以拋個異常試試 
    53. 
  
  
  53.         //if (i == 43) { throw new NotSupportedException("異常測試"); } 
    54. 
  
  
  54.  
    55. 
  
  
  55.         //可以隨時再次操作等待窗體的各種UI元素 
    56. 
  
  
  56.         //if (i % 10 == 0) { WaitUI.CancelControlVisible = false; }   //隱藏取消控件 
    57. 
  
  
  57.         //else if (i % 5 == 0) { WaitUI.CancelControlVisible = true; }//顯示取消控件 
    58. 
  
  
  58.         WaitUI.WorkMessage = "正在XXOO，已完成 " + i + " 下..."; //更新進度描述 
    59. 
  
  
  59.         WaitUI.BarValue = i;//更新進度值 
    60. 
  
  
  60.         //WaitUI.BarPerformStep();//步進進度條 
    61. 
  
  
  61.  
    62. 
  
  
  62.         Thread.Sleep(100); 
    63. 
  
  
  63.     } 
    64. 
  
  
  64.     return i; 
    65. 
  
  
  65. } 
    66.

看完示例，熟悉套路的你可能都已經能洞悉實現(xiàn)細節(jié)了，不過作為方案分享文章，我還是照章講一下使用說明先，后面再掰扯設計說明，先看類圖：

使用說明：

WaitUI通過RunAction、RunFunc、RunDelegate這3個基本方法和它們的重載執(zhí)行任務，看名字就知道，它們依次是執(zhí)行無返回值方法、有返回值方法和自定義委托，每個方法都有不指定等待窗體和指定等待窗體兩種重載形態(tài)，不指定時就使用方案自帶的WaitForm作為等待窗體。自定義等待窗體需實現(xiàn)IWaitForm接口，詳情在后面的設計說明部分有說。這 里就表示等待窗體是在執(zhí)行任務時才傳進去的，任務執(zhí)行完成后，WaitUI會銷毀等待窗體，這是為了讓WaitUI作為一個靜態(tài)類，盡量短暫的持有對象， 節(jié)約內存。所以如果傳入的是自定義等待窗體的變量，請注意不要在WaitRun之后再次使用該變量，因為它已經被銷毀，推薦的做法是直接在RunXXX中 new一個自定義等待窗體。當然如果不嫌棄自帶等待窗體，直接就不用傳入，自然不會有這個問題。前兩種方法是泛型方法，根據(jù)Action和Func這倆泛型委托重載，這倆委托支持到最多16個參數(shù)，但為了節(jié)約篇幅，方案中只重載了0~8個參數(shù)的情況，用戶可以根據(jù)需要增加重載。它 倆可以執(zhí)行任意不多于8個參數(shù)的有返回或無返回方法，得益于編譯器的智能推斷，使用時非常方便，直接RunAction(Foo, arg1, arg2, ...)就好了，根本不用糾結到底要使用哪個重載。對于RunDelegate方法，接受的是一個委托實例，也就是不能直接傳入方法，必須要用委托把方法 套上才行。任何委托都可以傳入，所以RunDelegate是最應萬變的方法，當你的方法存在ref/out參數(shù)，或者參數(shù)個數(shù)變態(tài)到超過16個時，你還 可以也只可以選用RunDelegate。但有個限制，委托有且只有綁定一個方法，RunXXX拒絕執(zhí)行委托鏈

RunFunc和RunDelegate方法有返回值，前者的返回類型與任務方法的返回類型一致，后者則是object。它倆的返回值就是任務方法的返回值。同樣，任務拋出的異常一樣會在3種RunXXX方法中拋出來，等于用RunXXX執(zhí)行任務與直接調用任務相比，除了寫法上有所不同：

 
 
    
  
  
  1. int a = WaitUI.RunFunc(Foo,33); 
    2. 
  
  
  2. int b = Foo(33); 
    3.

調用體驗是一樣一樣的，所以你拿去就可以用，不需要對任務方法做什么修改，帶個套就完事兒，除非任務方法存在下面這種情況

原理中說過，RunXXX方法實際上是調用任務所屬委托的BeginInvoke方法，也就是異步執(zhí)行任務，也就是任務會在另一個線程執(zhí)行。所以任務中不能訪問控件，這恐怕是該方案最大的不便，但確實原理所限，所以如果你的任務有訪問控件的代碼，還得做出改動才行。要問為什么非得讓任務在后臺，而等待窗體在前臺，不可以調換過來嗎？那樣不就沒這個不便了嗎？那是因為等待窗體如果不在主線程ShowDialog，它就達不到模式的效果，用戶仍然可以唱歌跳舞，這恐怕是你不愿意的

任務中可以通過WaitUI的一組屬性和方法（WorkMessage、BarValue、BarPerformStep等）更新等待窗體中的文 本呈現(xiàn)控件和進度指示控件（不限于Label和ProgressBar，取決于等待窗體的設計），用來向用戶報告任務執(zhí)行進度。當然不想做任何報告也可 以，就讓用戶面對一個“請稍候...”和循環(huán)滾動條也無不可，具體文字和滾動條樣式取決于等待窗體的默認設置

WaitUI有個CancelControlVisible屬性，可以設置為true/false控制等待窗體上是否顯示【取消】按鈕之類的控件 （不限于Button，取決于等待窗體的設計，所以下文不說取消按鈕，說取消控件）。這里需要詳細說一下該方案的取消任務的機制，其實與BackgroundWorker的機制一致（好吧是我借鑒了它），熟悉bgw的老鳥請略過。顯示取消控件只代表用戶可以請求終止任務，至于你（或者說任務）是否響應這 個請求（同意終止與否）是另一回事。什么意思，就是用戶點擊取消控件后，不是說任務就會自動終止了~憑什么會終止嘛對吧，任務在線程池，又不可能 Abort，所以任務是否終止完全取決你在任務代碼中的處理，比如你在任務中段就來個return或throw ex，這個就叫終止，任由代碼執(zhí)行下去，就叫做沒終止，所以用戶請求終止與任務是不是真的終止了沒有必然聯(lián)系。說這么多是什么意思，就是如果你要讓用戶看 到取消控件，那么你就應該響應用戶的請求，反過來如果不想任務被終止，那么就別讓用戶有發(fā)起請求的可能，當然這是與技術無關的純人機交互理念的東西，沒有 對錯，反正我是建議不要欺騙用戶，下面說說如何響應終止請求。當用戶發(fā)起終止請求后，WaitUI的UserCancelling會變?yōu)閠rue，在任務 中你可以根據(jù)這個值來做出終止任務的處理，但是在終止之前，還得麻煩你設置一個標記，千萬別忘記，就是讓WaitUI.Cancelled = true，這等于告訴執(zhí)行器任務確實終止了，在設置完標記后，最好緊跟終止代碼，不要再做其它事，讓Cancelled與事實一致。執(zhí) 行器中根據(jù)Cancelled來獲知任務是否已終止，進而做出相應的處理和返回。為什么不根據(jù)UserCancelling而是Cancelled相信你 已經明白了，前者是用戶的意愿，后者是開發(fā)者的決定，當然是決定靠譜?；氐紺ancelControlVisible屬性，這個屬性建議在任務方法頂部就 設置，因為一個任務是否可終止應該是確定的，通常來說，循環(huán)類任務是可以終止的，例如批量處理圖片，一圈處理一張，那這種任務是可以也應該允許用戶終止 的；而非循環(huán)類任務，或者原子性比較強的任務，開始了就只能等待結果或報錯，這種任務一方面可能就不允許用戶終止，另一方面則是想終止都終止不了（比如 WebRequest.GetResponse、SqlCommand.ExecuteNonQuery之類），這種任務最好就不提供取消控件給用戶。不 過CancelControlVisible也像WorkMessage之類的屬性一樣，是可以在任務中隨時+反復設置的，所以你的任務可能有些階段可被 終止，有時則不允許終止，開開合合都是可以的，as you wish
RunXXX有3種執(zhí)行結果：①成功執(zhí)行任務，返回任務返回值~如果任務有返回值的話；②任務產生異常，RunXXX會原樣拋出該異常；③任務被終止，拋出WorkCancelledException異常（后面有關于為什么選擇拋異常這種方式的說明）。你自行根據(jù)不同結果做相應處理

對于有ref/out參數(shù)的任務方法，如果你想在任務執(zhí)行后取回，請注意要這樣：

 
 
    
  
  
  1. //正確 
    2. 
  
  
  2. object[] prms = { a, b }; 
    3. 
  
  
  3. WaitUI.RunDelegate(new Action(Foo), prms); 
    4. 
  
  
  4. a = prms[0]; 
    5. 
  
  
  5. b = prms[1]; 
    6. 
  
  
  6.  
    7. 
  
  
  7. //錯誤 
    8. 
  
  
  8. WaitUI.RunDelegate(new Action(Foo), a, b); 
    9.

 

即要先構造好參數(shù)數(shù)組（哪怕只有1個參數(shù)），完了傳入數(shù)組，最后從數(shù)組中取出的元素才是被蹂躡過的。不能直接傳入單個參數(shù)變量，那樣你是不能通過該變量取回改動過的值的，具體原因自己悟

方案源碼：

WaitUI.cs包含class WaitUI和3個異常類WaitFormNullException、WorkIsBusyException、WorkCancelledException

 
 
    
  
  
  1. using System; 
    2. 
  
  
  2. using System.Reflection; 
    3. 
  
  
  3. using System.Windows.Forms; 
    4. 
  
  
  4.  
    5. 
  
  
  5. namespace AhDung.WinForm 
    6. 
  
  
  6. { 
    7. 
  
  
  7.     ///  
    8. 
  
  
  8.     /// 執(zhí)行任務并顯示等候窗體 
    9. 
  
  
  9.     ///  
    10. 
  
  
  10.     public static class WaitUI 
    11. 
  
  
  11.     { 
    12. 
  
  
  12.         static IWaitForm waitForm; //等待窗體 
    13. 
  
  
  13.         static object result;      //任務返回結果 
    14. 
  
  
  14.         static Exception exception;//任務執(zhí)行異常 
    15. 
  
  
  15.  
    16. 
  
  
  16.         static object[] parmsInput;        //調用者傳入的參數(shù) 
    17. 
  
  
  17.         static ParameterInfo[] parmsMethod;//任務所需的參數(shù) 
    18. 
  
  
  18.         static bool isCallBackCompleted;   //指示回調方法是否已執(zhí)行完畢 
    19. 
  
  
  19.  
    20. 
  
  
  20.         ///  
    21. 
  
  
  21.         /// 指示用戶是否已請求取消任務 
    22. 
  
  
  22.         ///  
    23. 
  
  
  23.         public static bool UserCancelling 
    24. 
  
  
  24.         { 
    25. 
  
  
  25.             get; 
    26. 
  
  
  26.             private set; 
    27. 
  
  
  27.         } 
    28. 
  
  
  28.  
    29. 
  
  
  29.         ///  
    30. 
  
  
  30.         /// 指示任務是否已取消 
    31. 
  
  
  31.         ///  
    32. 
  
  
  32.         public static bool Cancelled 
    33. 
  
  
  33.         { 
    34. 
  
  
  34.             private get; 
    35. 
  
  
  35.             set; 
    36. 
  
  
  36.         } 
    37. 
  
  
  37.  
    38. 
  
  
  38.         ///  
    39. 
  
  
  39.         /// 指示任務是否正在執(zhí)行中 
    40. 
  
  
  40.         ///  
    41. 
  
  
  41.         public static bool IsBusy 
    42. 
  
  
  42.         { 
    43. 
  
  
  43.             get; 
    44. 
  
  
  44.             private set; 
    45. 
  
  
  45.         } 
    46. 
  
  
  46.  
    47. 
  
  
  47.         #region 一系列操作等候窗體UI的屬性/方法 
    48. 
  
  
  48.  
    49. 
  
  
  49.         ///  
    50. 
  
  
  50.         /// 獲取或設置進度描述 
    51. 
  
  
  51.         ///  
    52. 
  
  
  52.         public static string WorkMessage 
    53. 
  
  
  53.         { 
    54. 
  
  
  54.             get 
    55. 
  
  
  55.             { 
    56. 
  
  
  56.                 if (waitForm.InvokeRequired) 
    57. 
  
  
  57.                 { 
    58. 
  
  
  58.                     return waitForm.Invoke(new Func(() => waitForm.WorkMessage)) as string; 
  
  
  59.                 } 
    60. 
  
  
  60.                 return waitForm.WorkMessage; 
    61. 
  
  
  61.             } 
    62. 
  
  
  62.             set 
    63. 
  
  
  63.             { 
    64. 
  
  
  64.                 if (waitForm == null) { return; } 
    65. 
  
  
  65.  
    66. 
  
  
  66.                 if (waitForm.InvokeRequired) 
    67. 
  
  
  67.                 { 
    68. 
  
  
  68.                     waitForm.BeginInvoke(new Action(() => waitForm.WorkMessage = value)); 
    69. 
  
  
  69.                     return; 
    70. 
  
  
  70.                 } 
    71. 
  
  
  71.                 waitForm.WorkMessage = value; 
    72. 
  
  
  72.             } 
    73. 
  
  
  73.         } 
    74. 
  
  
  74.  
    75. 
  
  
  75.         ///  
    76. 
  
  
  76.         /// 獲取或設置進度條可見性 
    77. 
  
  
  77.         ///  
    78. 
  
  
  78.         public static bool BarVisible 
    79. 
  
  
  79.         { 
    80. 
  
  
  80.             get 
    81. 
  
  
  81.             { 
    82. 
  
  
  82.                 if (waitForm.InvokeRequired) 
    83. 
  
  
  83.                 { 
    84. 
  
  
  84.                     return Convert.ToBoolean(waitForm.Invoke(new Func(() => waitForm.BarVisible))); 
  
  
  85.                 } 
    86. 
  
  
  86.                 return waitForm.BarVisible; 
    87. 
  
  
  87.             } 
    88. 
  
  
  88.             set 
    89. 
  
  
  89.             { 
    90. 
  
  
  90.                 if (waitForm == null) { return; } 
    91. 
  
  
  91.  
    92. 
  
  
  92.                 if (waitForm.InvokeRequired) 
    93. 
  
  
  93.                 { 
    94. 
  
  
  94.                     waitForm.BeginInvoke(new Action(() => waitForm.BarVisible = value)); 
    95. 
  
  
  95.                     return; 
    96. 
  
  
  96.                 } 
    97. 
  
  
  97.                 waitForm.BarVisible = value; 
    98. 
  
  
  98.             } 
    99. 
  
  
  99.         } 
    100. 
  
  
  100.  
    101. 
  
  
  101.         ///  
    102. 
  
  
  102.         /// 獲取或設置進度條動畫樣式 
    103. 
  
  
  103.         ///  
    104. 
  
  
  104.         public static ProgressBarStyle BarStyle 
    105. 
  
  
  105.         { 
    106. 
  
  
  106.             get 
    107. 
  
  
  107.             { 
    108. 
  
  
  108.                 if (waitForm.InvokeRequired) 
    109. 
  
  
  109.                 { 
    110. 
  
  
  110.                     return (ProgressBarStyle)(waitForm.Invoke(new Func(() => waitForm.BarStyle))); 
  
  
  111.                 } 
    112. 
  
  
  112.                 return waitForm.BarStyle; 
    113. 
  
  
  113.             } 
    114. 
  
  
  114.             set 
    115. 
  
  
  115.             { 
    116. 
  
  
  116.                 if (waitForm == null) { return; } 
    117. 
  
  
  117.  
    118. 
  
  
  118.                 if (waitForm.InvokeRequired) 
    119. 
  
  
  119.                 { 
    120. 
  
  
  120.                     waitForm.BeginInvoke(new Action(() => waitForm.BarStyle = value)); 
    121. 
  
  
  121.                     return; 
    122. 
  
  
  122.                 } 
    123. 
  
  
  123.                 waitForm.BarStyle = value; 
    124. 
  
  
  124.             } 
    125. 
  
  
  125.         } 
    126. 
  
  
  126.  
    127. 
  
  
  127.         ///  
    128. 
  
  
  128.         /// 獲取或設置進度值 
    129. 
  
  
  129.         ///  
    130. 
  
  
  130.         public static int BarValue 
    131. 
  
  
  131.         { 
    132. 
  
  
  132.             get 
    133. 
  
  
  133.             { 
    134. 
  
  
  134.                 if (waitForm.InvokeRequired) 
    135. 
  
  
  135.                 { 
    136. 
  
  
  136.                     return Convert.ToInt32(waitForm.Invoke(new Func(() => waitForm.BarValue))); 
  
  
  137.                 } 
    138. 
  
  
  138.                 return waitForm.BarValue; 
    139. 
  
  
  139.             } 
    140. 
  
  
  140.             set 
    141. 
  
  
  141.             { 
    142. 
  
  
  142.                 if (waitForm == null) { return; } 
    143. 
  
  
  143.  
    144. 
  
  
  144.                 if (waitForm.InvokeRequired) 
    145. 
  
  
  145.                 { 
    146. 
  
  
  146.                     waitForm.BeginInvoke(new Action(() => waitForm.BarValue = value)); 
    147. 
  
  
  147.                     return; 
    148. 
  
  
  148.                 } 
    149. 
  
  
  149.                 waitForm.BarValue = value; 
    150. 
  
  
  150.             } 
    151. 
  
  
  151.         } 
    152. 
  
  
  152.  
    153. 
  
  
  153.         ///  
    154. 
  
  
  154.         /// 獲取或設置進度條步進值 
    155. 
  
  
  155.         ///  
    156. 
  
  
  156.         public static int BarStep 
    157. 
  
  
  157.         { 
    158. 
  
  
  158.             get 
    159. 
  
  
  159.             { 
    160. 
  
  
  160.                 if (waitForm.InvokeRequired) 
    161. 
  
  
  161.                 { 
    162. 
  
  
  162.                     return Convert.ToInt32(waitForm.Invoke(new Func(() => waitForm.BarStep))); 
  
  
  163.                 } 
    164. 
  
  
  164.                 return waitForm.BarStep; 
    165. 
  
  
  165.             } 
    166. 
  
  
  166.             set 
    167. 
  
  
  167.             { 
    168. 
  
  
  168.                 if (waitForm == null) { return; } 
    169. 
  
  
  169.  
    170. 
  
  
  170.                 if (waitForm.InvokeRequired) 
    171. 
  
  
  171.                 { 
    172. 
  
  
  172.                     waitForm.BeginInvoke(new Action(() => waitForm.BarStep = value)); 
    173. 
  
  
  173.                     return; 
    174. 
  
  
  174.                 } 
    175. 
  
  
  175.                 waitForm.BarStep = value; 
    176. 
  
  
  176.             } 
    177. 
  
  
  177.         } 
    178. 
  
  
  178.  
    179. 
  
  
  179.         ///  
    180. 
  
  
  180.         /// 使進度條步進 
    181. 
  
  
  181.         ///  
    182. 
  
  
  182.         public static void BarPerformStep() 
    183. 
  
  
  183.         { 
    184. 
  
  
  184.             if (waitForm == null) { return; } 
    185. 
  
  
  185.  
    186. 
  
  
  186.             if (waitForm.InvokeRequired) 
    187. 
  
  
  187.             { 
    188. 
  
  
  188.                 waitForm.BeginInvoke(new Action(() => waitForm.BarPerformStep())); 
    189. 
  
  
  189.                 return; 
    190. 
  
  
  190.             } 
    191. 
  
  
  191.             waitForm.BarPerformStep(); 
    192. 
  
  
  192.         } 
    193. 
  
  
  193.  
    194. 
  
  
  194.         ///  
    195. 
  
  
  195.         /// 獲取或設置進度條上限值 
    196. 
  
  
  196.         ///  
    197. 
  
  
  197.         public static int BarMaximum 
    198. 
  
  
  198.         { 
    199. 
  
  
  199.             get 
    200. 
  
  
  200.             { 
    201. 
  
  
  201.                 if (waitForm.InvokeRequired) 
    202. 
  
  
  202.                 { 
    203. 
  
  
  203.                     return Convert.ToInt32(waitForm.Invoke(new Func(() => waitForm.BarMaximum))); 
  
  
  204.                 } 
    205. 
  
  
  205.                 return waitForm.BarMaximum; 
    206. 
  
  
  206.             } 
    207. 
  
  
  207.             set 
    208. 
  
  
  208.             { 
    209. 
  
  
  209.                 if (waitForm == null) { return; } 
    210. 
  
  
  210.  
    211. 
  
  
  211.                 if (waitForm.InvokeRequired) 
    212. 
  
  
  212.                 { 
    213. 
  
  
  213.                     waitForm.BeginInvoke(new Action(() => waitForm.BarMaximum = value)); 
    214. 
  
  
  214.                     return; 
    215. 
  
  
  215.                 } 
    216. 
  
  
  216.                 waitForm.BarMaximum = value; 
    217. 
  
  
  217.             } 
    218. 
  
  
  218.         } 
    219. 
  
  
  219.  
    220. 
  
  
  220.         ///  
    221. 
  
  
  221.         /// 獲取或設置進度條下限值 
    222. 
  
  
  222.         ///  
    223. 
  
  
  223.         public static int BarMinimum 
    224. 
  
  
  224.         { 
    225. 
  
  
  225.             get 
    226. 
  
  
  226.             { 
    227. 
  
  
  227.                 if (waitForm.InvokeRequired) 
    228. 
  
  
  228.                 { 
    229. 
  
  
  229.                     return Convert.ToInt32(waitForm.Invoke(new Func(() => waitForm.BarMinimum))); 
  
  
  230.                 } 
    231. 
  
  
  231.                 return waitForm.BarMinimum; 
    232. 
  
  
  232.             } 
    233. 
  
  
  233.             set 
    234. 
  
  
  234.             { 
    235. 
  
  
  235.                 if (waitForm == null) { return; } 
    236. 
  
  
  236.  
    237. 
  
  
  237.                 if (waitForm.InvokeRequired) 
    238. 
  
  
  238.                 { 
    239. 
  
  
  239.                     waitForm.BeginInvoke(new Action(() => waitForm.BarMinimum = value)); 
    240. 
  
  
  240.                     return; 
    241. 
  
  
  241.                 } 
    242. 
  
  
  242.                 waitForm.BarMinimum = value; 
    243. 
  
  
  243.             } 
    244. 
  
  
  244.         } 
    245. 
  
  
  245.  
    246. 
  
  
  246.         ///  
    247. 
  
  
  247.         /// 獲取或設置取消任務的控件的可見性 
    248. 
  
  
  248.         ///  
    249. 
  
  
  249.         public static bool CancelControlVisible 
    250. 
  
  
  250.         { 
    251. 
  
  
  251.             get 
    252. 
  
  
  252.             { 
    253. 
  
  
  253.                 if (waitForm.InvokeRequired) 
    254. 
  
  
  254.                 { 
    255. 
  
  
  255.                     return Convert.ToBoolean(waitForm.Invoke(new Func(() => waitForm.CancelControlVisible))); 
  
  
  256.                 } 
    257. 
  
  
  257.                 return waitForm.CancelControlVisible; 
    258. 
  
  
  258.             } 
    259. 
  
  
  259.             set 
    260. 
  
  
  260.             { 
    261. 
  
  
  261.                 if (waitForm == null) { return; } 
    262. 
  
  
  262.  
    263. 
  
  
  263.                 if (waitForm.InvokeRequired) 
    264. 
  
  
  264.                 { 
    265. 
  
  
  265.                     waitForm.BeginInvoke(new Action(() => waitForm.CancelControlVisible = value)); 
    266. 
  
  
  266.                     return; 
    267. 
  
  
  267.                 } 
    268. 
  
  
  268.                 waitForm.CancelControlVisible = value; 
    269. 
  
  
  269.             } 
    270. 
  
  
  270.         } 
    271. 
  
  
  271.  
    272. 
  
  
  272.         #endregion 
    273. 
  
  
  273.  
    274. 
  
  
  274.         #region 公共方法：無返回值+默認窗體 
    275. 
  
  
  275.  
    276. 
  
  
  276.         ///  
    277. 
  
  
  277.         /// 執(zhí)行方法并顯示默認等候窗體 
    278. 
  
  
  278.         ///  
    279. 
  
  
  279.         public static void RunAction(Action method) 
    280. 
  
  
  280.         { 
    281. 
  
  
  281.             RunDelegate(method); 
    282. 
  
  
  282.         } 
    283. 
  
  
  283.  
    284. 
  
  
  284.         ///  
    285. 
  
  
  285.         /// 執(zhí)行方法并顯示默認等候窗體 
    286. 
  
  
  286.         ///  
    287. 
  
  
  287.         public static void RunAction(Action method, T arg) 
    288. 
  
  
  288.         { 
    289. 
  
  
  289.             RunDelegate(method, arg); 
    290. 
  
  
  290.         } 
    291. 
  
  
  291.  
    292. 
  
  
  292.         ///  
    293. 
  
  
  293.         /// 執(zhí)行方法并顯示默認等候窗體 
    294. 
  
  
  294.         ///  
    295. 
  
  
  295.         public static void RunAction(Action method, T1 arg1, T2 arg2) 
    296. 
  
  
  296.         { 
    297. 
  
  
  297.             RunDelegate(method, arg1, arg2); 
    298. 
  
  
  298.         } 
    299. 
  
  
  299.  
    300. 
  
  
  300.         ///  
    301. 
  
  
  301.         /// 執(zhí)行方法并顯示默認等候窗體 
    302. 
  
  
  302.         ///  
    303. 
  
  
  303.         public static void RunAction(Action method, T1 arg1, T2 arg2, T3 arg3) 
    304. 
  
  
  304.         { 
    305. 
  
  
  305.             RunDelegate(method, arg1, arg2, arg3); 
    306. 
  
  
  306.         } 
    307. 
  
  
  307.  
    308. 
  
  
  308.         ///  
    309. 
  
  
  309.         /// 執(zhí)行方法并顯示默認等候窗體 
    310. 
  
  
  310.         ///  
    311. 
  
  
  311.         public static void RunAction(Action method, T1 arg1, T2 arg2, T3 arg3, T4 arg4) 
    312. 
  
  
  312.         { 
    313. 
  
  
  313.             RunDelegate(                                                
    
                                                本文名稱：【C#】分享帶等待窗體的任務執(zhí)行器一枚                                                
    
                                                文章出自：http://m.5511xx.com/article/dpgpisd.html
                                            
                                            
                                        
                                    
                                
                            
                        
                    
                
            
        
    










  315.