※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益

有別於一般網頁架設公司，除了模組化的架站軟體，我們的營業主軸還包含：資料庫程式開發、網站建置、網頁設計、電子商務專案開發、系統整合、APP設計建置、專業網路行銷。

觀察者模式簡述

觀察者（Observer）模式的定義：指多個對象間存在一對多的依賴關係，當一個對象的狀態發生改變時，所有依賴於它的對象都得到通知並被自動更新。這種模式有時又稱作發布-訂閱模式、模型-視圖模式，它是對象行為型模式。

觀察者模式結構與實現

 實現觀察者模式時要注意具體目標對象和具體觀察者對象之間不能直接調用，否則將使兩者之間緊密耦合起來，這違反了面向對象的設計原則。

觀察者模式主要結構如下：

• 抽象主題（Subject）角色：也叫抽象目標類，它提供了一個用於保存觀察者對象的聚集類和增加、刪除觀察者對象的方法，以及通知所有觀察者的抽象方法。
• 具體主題（Concrete    Subject）角色：也叫具體目標類，它實現抽象目標中的通知方法，當具體主題的內部狀態發生改變時，通知所有註冊過的觀察者對象。
• 抽象觀察者（Observer）角色：它是一個抽象類或接口，它包含了一個更新自己的抽象方法，當接到具體主題的更改通知時被調用。
• 具體觀察者（Concrete Observer）角色：實現抽象觀察者中定義的抽象方法，以便在得到目標的更改通知時更新自身的狀態。

uml圖如下：

 觀察者模式代碼實現如下：

/**
 * 抽象主題（被觀察角色）
 */
public abstract class Subject{
    //觀察者list集合（聚集對象）
    protected List<Observer> observerList=new ArrayList<Observer>();
    //註冊觀察者
    public void addObserver(Observer observer){
        observerList.add(observer);
    }
    //刪除觀察者
    public void removeObserver(Observer observer){
        if(observerList.contains(observer)){
            observerList.remove(observer);

        }
    }
    //通知觀察者
    public abstract void notifyObserver();
}

/**
 * 具體主題角色類（被觀察的類）
 */
public class ConcreteSubject extends Subject{
    @Override
    public void notifyObserver() {
        System.out.println("被觀察者發現變化了...");
        for(Observer observer:super.observerList){
            observer.update();
        }

    }
}

/**
 * 抽象觀察者
 */
public interface Observer {
    public void update();
}


/**
 * 具體觀察者類
 */
public class ConcreteObserver1 implements Observer {
    @Override
    public void update() {
        System.out.println("observe1 更新了");
    }
}

/**
 * 具體觀察者
 */
public class ConcreteObserver2 implements Observer {
    @Override
    public void update() {
        System.out.println("observer2 發生變更");
    }
}


/**
 * 客戶端測試類
 */
public class ObserverClient {
    public static void main(String[] args) {

        Subject subject=new ConcreteSubject();
        Observer observer1=new ConcreteObserver1();
        Observer observer2=new ConcreteObserver2();
        subject.addObserver(observer1);
        subject.addObserver(observer2);
        //具體主題發生變化通知觀察者。
        subject.notifyObserver();

    }
}

觀察者模式案例

1.利用觀察者模式設計一個程序，分析“人民幣匯率”的升值或貶值對進口公司的進口產品成本或出口公司的出口產品收入以及公司的利潤率的影響。

分析：。被觀察的抽象主題對象就是匯率Rate，以人民幣匯率RMBRate為具體主題。以公司Company為抽象觀察者，出口公司ExportCompany為具體的觀察者，進口公司ImportCompany為具體的觀察者，人民幣匯率(具體主題角色)升值時，進口公司（具體觀察者對象）的進口產品成本降低且利潤率提升，出口公司（具體觀察者對象）的出口產品收入降低且利潤率降低；當人民幣匯率貶值時，進口公司的進口產品成本提升且利潤率降低，出口公司的出口產品收入提升且利潤率提升。總而言之當主題角色匯率發生變化時，觀察者Company的利潤也相應發生變化。

uml圖如下：

 代碼實現如下：

※Google地圖已可更新顯示潭子電動車充電站設置地點!!

日本、大陸，發現這些先進的國家已經早就讓電動車優先上路，而且先進國家空氣品質相當好，電動車節能減碳可以減少空污

/**
 * 抽象觀察者
 */
public interface Company {
    void update(int changeRate);
}

/**
 * 具體觀察者進口公司ExportCompany
 */
public class ExportCompany implements Company {
    @Override
    public void update(int changeRate) {
        if(changeRate>=0){
            System.out.println("人民幣匯率升值"+changeRate+"個基點，降低了進口產品成本，提升了進口公司利潤率");

        } else {
            System.out.println("人民幣匯率貶值"+(0-changeRate)+"個基點，提升了進口產品成本，降低了進口公司利潤率。");

        }
    }
}


/**
 * 具體觀察者進口公司importCompany
 */
public class ImportCompany implements Company {
    @Override
    public void update(int changeRate) {
        if(changeRate>=0){
            System.out.println("人民幣匯率升值"+changeRate+"個基點，降低了進口產品成本，提升了進口公司利潤率");

        } else {
            System.out.println("人民幣匯率貶值"+(0-changeRate)+"個基點，提升了進口產品成本，降低了進口公司利潤率。");

        }
    }
}

/**
 * 抽象主題角色
 */
public abstract class Rate {
    //觀察者company對象list集合
    protected List<Company> companyList=new ArrayList<Company>();
    //增加觀察者company對象
    public void addObserver(Company company){
        companyList.add(company);
    }
    //刪除觀察者company對象
    public void removeObserver(Company company){
        companyList.remove(company);
    }
    public abstract void change(int rateChange);
}

/**
 * 具體主題對象人民幣匯率RMBRate
 */
public class RMBRate extends Rate {

    @Override
    public void change(int rateChange) {
        for (Company company:super.companyList){
            company.update(rateChange);
        }
    }
}
/**
 * 匯率變化觀察者模式實現客戶端類
 */
public class RateClient {
    public static void main(String[] args) {
        //具體觀察對像進口公司
        Company importCompany=new ImportCompany();
        //具體觀察者對象出口公司
        Company exportCompany=new ExportCompany();
        //具體主題角色人民幣對象
        Rate rmbRate=new RMBRate();
        //增添觀察者對象
        rmbRate.addObserver(importCompany);
        rmbRate.addObserver(exportCompany);
        //匯率提升
        rmbRate.change(2);
        //匯率降低
        rmbRate.change(-3);
    }
}

2.事件監聽模式就是利用觀察者模式實現的，java的awt窗體程序就是用觀察者模式實現的，在軟件幵發中窗體程序，界面程序都是基於事件監聽模式實現。現在以awt的Button的點擊事件為例，來了解一下事件監聽模式。首先創建一個按鈕Button類（事件源對象，被觀察者對象），將按鈕點擊監聽器註冊在Button上，當用戶點擊按鈕時，會產生一個按鈕點擊事件 ButtonClickEvent，將點擊事件傳給按鈕點擊監聽器 ButtonClickListener,監聽器做出相應的動作。

uml圖如下：

 代碼實現如下：

/**
 * 自定義按鈕類,事件源對象
 */
public class Button {
    private String buttonName;

    protected List<Listener> listenerlist = new ArrayList<Listener>();
    //註冊監聽器
    public void addListener(Listener listener){
        listenerlist.add(listener);
    }
    //移除監聽器
    public void removeListener(Listener listener){
        listenerlist.remove(listener);
    }
    //點擊方法
    public void press(){
        ButtonClickEvent event=new ButtonClickEvent(this);
        for (Listener listener:listenerlist){
            listener.actionPerformed(event);
        }
    }

    public String getButtonName() {
        return buttonName;
    }

    public void setButtonName(String buttonName) {
        this.buttonName = buttonName;
    }
}

package cn.ck.observer.v4;


import java.util.EventObject;

/**
 * 按鈕點擊事件
 */

public class ButtonClickEvent extends EventObject {
　　 private Object source;
    public ButtonClickEvent(Object source){
        this.source=source;
    }

}



/**
 * 抽象監聽器
 */
public interface Listener {
    public void actionPerformed(ButtonClickEvent event);


}



/**
 * 按鈕點擊監聽器 具體觀察者
 */
public class ButtonClickListener implements Listener {

    @Override
    public void actionPerformed(ButtonClickEvent event) {
       Button button= (Button) event.getSource();
        System.out.println(button.getButtonName()+"按鈕被點擊了...");
    }
}




/**
 * 按鈕事件測試類
 */
public class ButtonClient {
    public static void main(String[] args) {
        Button b1=new Button();
        Listener listener=new ButtonClickListener();
        b1.setButtonName("button1");
        Button b2=new Button();
        b2.setButtonName("button2");
        b1.addListener(listener);
        b2.addListener(listener);
        b1.press();
        b2.press();

    }
}

jdk的觀察模式通過 java.util.Observable 類和 java.util.Observer 接口定義的，只要實現它們的子類就可以編寫觀察者模式實例。

1. Observable類

Observable 類是抽象目標類，它有一個 Vector 集合，用於保存所有要通知的觀察者對象，下面來介紹它最重要的 3 個方法。

1. void addObserver(Observer o) 方法：用於將新的觀察者對象添加到向中Vector集合（線程安全）。
2. void notifyObservers(Object arg) 方法：調用Vector集合中的所有觀察者對象的 update。方法，通知它們數據發生改變。通常越晚加入向量的觀察者越先得到通知。
3. void setChange() 方法：用來設置一個 boolean 類型的內部標誌位，註明目標對象發生了變化。當它為真時，notifyObservers() 才會通知觀察者。

2. Observer 接口

Observer 接口是抽象觀察者，它監視目標對象的變化，當目標對象發生變化時，觀察者得到通知，並調用 void update(Observable o,Object arg) 方法，進行相應的工作。

還是以上面匯率的例子為例，用jdk的抽象觀察者，抽象目標類實現觀察者模式，具體代碼如下：

/**
 * 具體主題對象人民幣匯率RMBRate
 */
public class RMBRate extends Observable{

    public void change (int rateChange) {
        //changed變成true
        super.setChanged();
        super.notifyObservers(rateChange);
    }
}


/**
 * 具體觀察者進口公司ExportCompany
 */
public class ExportCompany implements Observer{

    @Override
    public void update(Observable o, Object arg) {
        int changeRate= (int) arg;
        if(changeRate>=0){
            System.out.println("人民幣匯率升值"+changeRate+"個基點，降低了進口產品成本，提升了進口公司利潤率");

        } else {
            System.out.println("人民幣匯率貶值"+(0-changeRate)+"個基點，提升了進口產品成本，降低了進口公司利潤率。");

        }

    }
}

/**
 * 具體觀察者進口公司importCompany
 */
public class ImportCompany implements Observer {
    @Override
    public void update(Observable o, Object arg) {
        int changeRate= (int) arg;
        if(changeRate>=0){
            System.out.println("人民幣匯率升值"+changeRate+"個基點，降低了進口產品成本，提升了進口公司利潤率");

        } else {
            System.out.println("人民幣匯率貶值"+(0-changeRate)+"個基點，提升了進口產品成本，降低了進口公司利潤率。");

        }

    }
}


/**
 * 匯率變化觀察者模式實現客戶端類
 */
public class RateClient {
    public static void main(String[] args) {
        //具體觀察對像進口公司
        Observer importCompany=new ImportCompany();
        //具體觀察者對象出口公司
        Observer exportCompany=new ExportCompany();
        //具體主題角色人民幣對象
        RMBRate rmbRate=new RMBRate();
        //增添觀察者對象
        rmbRate.addObserver(importCompany);
        rmbRate.addObserver(exportCompany);
        //匯率提升
        rmbRate.change(2);
        //匯率降低
        rmbRate.change(-3);

    }
}

觀察者模式優點與缺點

1.觀察者模式優點

• 降低了目標與觀察者之間的耦合關係，兩者之間是抽象耦合關係。
• 目標與觀察者之間建立了一套觸發機制。

2.觀察者模式缺點

• 目標與觀察者之間的依賴關係並沒有完全解除，而且有可能出現循環引用（可以通過事件類引用一個目標對象解決這個問題）。
• 當觀察者對象很多時，通知的發布會花費很多時間，影響程序的效率。

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

※Google地圖已可更新顯示潭子電動車充電站設置地點!!

日本、大陸，發現這些先進的國家已經早就讓電動車優先上路，而且先進國家空氣品質相當好，電動車節能減碳可以減少空污

※產品缺大量曝光嗎?你需要的是一流包裝設計!

窩窩觸角包含自媒體、自有平台及其他國家營銷業務等，多角化經營並具有國際觀的永續理念。

在以前的博文中，時常有分享Fiddler的一些使用技巧，今天再貼下。

Fiddler抓包工具使用詳解

利用Fiddler攔截接口請求並篡改數據

Fiddler使用過程中容易忽略的小技巧

Mock測試，結合Fiddler輕鬆搞定不同場景

以上這些，就是以前的一些實踐總結。今天，再來分享一個不可不知的小技巧，實際工作當中，是可以輔助自己完成測試的。

模擬弱網

相信大家在進行測試過程中，都會關注到弱網測試。web端是可以通過瀏覽器的開發者工具中的Network設置網絡數據，app端也可以通過切換網絡的形式來進行測試。

其實，Fiddler也是支持模擬弱網測試的。通過Fiddler設置后，web和app都可以一併模式。

固定延遲設置方式

啟動Fiddler工具>找到FiddlerScript頁簽>按m_SimulateModem搜索。

找到如下所示內容【限速函數】，修改參數即可：

修改代碼中的參數，將300修改為3000，也就是3S，如下：

if (m_SimulateModem) {
            // Delay sends by 300ms per KB uploaded.
            oSession["request-trickle-delay"] = "3000"; 
            // Delay receives by 150ms per KB downloaded.
            oSession["response-trickle-delay"] = "150"; 
        }　　

此時，保存修改后的Script代碼即可，如下所示：

數據保存后，如何使其生效呢？按如下操作即可。

在Fiddler中，按如下路徑配置即可：Rules>Performance>Simulate Modem Speeds。

具體操作，如下圖所示：

此時，再刷新頁面，我們可以從Fiddler面板中的Time參數看出，每個接口的響應時間都延時3s，如下所示：

網絡延遲時間如何計算？

比如你要模擬上傳速度100KBps的網絡，那上傳延遲就是1KB/100KBps=0.01s=10ms，就改成10。

隨機延遲設置方式

我們從上述操作看出，配置限速參數后，每個接口都是固定的延遲時間。但實際使用場景中，這種情況是比較少的。基本上都是有時快，有時慢的情況。那是否可以設置隨機延遲呢？答案肯定是可以的。我們繼續來看。

我們依然在FiddlerScript頁簽中操作，加入如下代碼，代碼如下所示：

static function randInt(min, max) {
　　return Math.round(Math.random()*(max-min)+min);
　　}
　　if (m_SimulateModem) {
　　// Delay sends by 300ms per KB uploaded.
　　oSession["request-trickle-delay"] = ""+randInt(1,2000);
　　// Delay receives by 150ms per KB downloaded.
　　oSession["response-trickle-delay"] = ""+randInt(1,2000);
　　}　　

保存修改后的代碼，並重新啟用配置即可。

模擬發包

測試過程中，想模擬一個接口請求，一般是通過Postman、Jmeter、soupUI，常用的是Postman。我們Fiddler能不能模擬接口請求呢？這個是可以的，我們來看。

我們切換到Composer頁簽，如下所示：

從圖中可知，是可以模擬很多種請求方式的。我們就來實際操作一番。

POST請求

我們先來操作個POST請求，選擇POST請求方式，填寫接口與參數如下：

※自行創業缺乏曝光? 網頁設計幫您第一時間規劃公司的形象門面

網動廣告出品的網頁設計，採用精簡與質感的CSS語法，提升企業的專業形象與簡約舒適的瀏覽體驗，讓瀏覽者第一眼就愛上她。

接口與參數填寫正確后，點擊右上角的Execute按鈕即可請求接口。我們來看下請求數據：

我們先來看請求頭，接口請求頭中的User-Agent參數，如下所示：

用戶代理來源是Fiddler，就是剛才我們通過Fiddler工具請求的數據。

我們再來看響應，接口請求成功，正常響應並獲取到token數據，如下所示：

GET請求

剛才操作的是POST請求，現在來看個GET請求。操作方式都一樣，將請求方式切換成GET，填寫接口與參數，並點擊Execute按鈕，配置如下所示：

我們依然來看接口數據，先看請求頭參數：

User-Agent參數依然是Fiddler，說明是從Fiddler工具中發出的請求。

再來看響應數據，如下所示：

以上就是通過Fiddler模擬請求POST和GET請求了，其他方式類似。

模擬併發

在我們測試中，也會關注到，一個接口同時請求多次，會不會產生錯誤，比如：重複數據。那這次就需要考慮併發情況了。

Fiddler工具依然還是支持該操作，具體如下：

我們先選中已抓取的任一接口，點擊右鍵，並選擇Replay>Reissue Sequentially，也可以快捷鍵【Shift + R】如下所示：

點擊后，會彈出如下彈框，設置請求次數，如下所示：

默認是5，那我們改成3，並點擊OK按鈕，來看界面，如下所示：

我們可以看到，同時請求了3次，簡單模擬了併發測試，但實際是不及Jmeter工具的，畢竟這個也只是模擬，而Jmeter要專業許多。

了解完了併發使用，但還有些其他參數沒有介紹，我們來了解下其他參數，說不準以後也有用途。如下所示：

• Reissue Requests：重發選中的請求
• Reissue Unconditinally：無條件重發選中的請求
• Reissue and eidt：重發並編輯，會打開一個加了斷點的請求，可以進行請求和響應數據的修改
• Reissue and verify：重發並驗證，重新發送請求，並驗證其請求結果，會自動加標識（背景顏色）
• Reissue Sequentially：重發序列，打開一個數量設置界面，標識需要重發多少次請求
• Reissue from Composer：重發並打開composer界面，可以編輯或發送
• Revisit in IE：在IE上發起這個請求

問題總結

在使用Fiddler模擬請求發包時，有時會操作失敗，比如通過百度查詢數據，GET接口，有時Caching參數不帶private參數就響應了302，正常帶該參數，是可以響應成功的，如下所示：

不知為何會出現，不帶該參數的情況。有遇到的博友，望提點一二。

好了，今天的這三個Fiddler技巧，就分享到這了，個人覺得在實際測試過程中，這三個技巧還是有幫助的。

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

※南投搬家公司費用需注意的眉眉角角，別等搬了再說!

上新台中搬家公司提供您一套專業有效率且人性化的辦公室搬遷、公司行號搬家及工廠遷廠的搬家服務

※台中搬家公司費用怎麼算?

擁有20年純熟搬遷經驗，提供免費估價且流程透明更是5星評價的搬家公司

前言

程序開發過程中,難免會有的業務邏輯,或者算法之類產生讓人能夠感知的耗時操作,例如循環中對複雜邏輯處理;獲取數據庫百萬乃至千萬級數據;http請求的時候等……
用戶在使用UI操作並不知道程序的內部處理,從而誤操作導致程序無響應,關閉程序等待影響體驗的情況,因此,在等待過程中提供友好的等待提示是有必要的,接下來
我們一起封裝一個自定義進度條控件!

主要使用技術(C#相關)

• BackgroundWoker異步模型
• ProgressBar控件
• 泛型
• 定時器 System.Timers.Timer

自定義控件開發

項目解決方案

• BackgroundworkerEx : 自定義進度條控件工程
• Test : 調用BackgroundworkerEx的工程(只是展示如何調用)

處理控件樣式

• 新建一個ProgressbarEx名稱的 用戶控件

• 添加Labal控件(lblTips),用於展示進度條显示的信息狀態

• 添加一個PictureBox控件(PicStop),充當關閉按鈕,用於獲取用戶點擊事件,觸發關閉/終止進度條

• 添加進度條ProgressBar控件(MainProgressBar)

• 處理代碼如下:

1. 進度條樣式為”不斷循環”,並且速度為50
2. 該自定義用戶控件不展示在任務欄中
3. 圖片控件被點擊事件——>設置當前屬性IsStop=true,指示過程終止;
4. TipMessage屬性,用於設置進度條的信息
5. SetProgressValue(int value) 設置進度條的Value屬性,使得在ProgressBarStyle.Marquee樣式中動畫平滑
6. MouseDown/MouseUp/MouseMove這三個事件是用於拖動無邊框的用戶控件(代碼就不貼了)

public ProgressbarEx()
{
    InitializeComponent();

    MainProgressBar.Style = ProgressBarStyle.Marquee;
    MainProgressBar.MarqueeAnimationSpeed = 50;

    this.ShowInTaskbar = false;

    PicStop.Click += (s, eve) =>
    {
    IsStop = true;
    };

    this.MouseDown += CusProgressForm_MouseDown;
    this.MouseUp += CusProgressForm_MouseUp;
    this.MouseMove += CusProgressForm_MouseMove;
}

/// <summary>
/// Need Stop ?
/// </summary>
public bool IsStop { get; private set; } = false;

/// <summary>
/// TipMessage
/// </summary>
public string TipMessage { get; set; }

/// <summary>
/// TipMessage
/// </summary>
public string TipMessage
{
    get
    {
    return lblTips.Text;
    }
    set
    {

    lblTips.Text = value;
    }
}

/// <summary>
/// Set ProgressBar value ,which makes ProgressBar smooth
/// </summary>
/// <param name="value"></param>
public void SetProgressValue(int value)
{
    if (MainProgressBar.Value == 100) MainProgressBar.Value = 0;

    MainProgressBar.Value += value;

}

到現在,這個自定義進度條控件的樣式基本完成了.

功能邏輯處理

運行前所需

• 定義BackgroundWorkerEx<T>泛型類,並且繼承於 IDisposable
  1. 釋放資源;

 		/// <summary>
        /// Dispose
        /// </summary>
        public void Dispose()
        {
            try
            {
                DoWork = null;
                RunWorkCompleted = null;
                WorkStoped = null;

                _mWorkerThread = null;
                _mWorker.Dispose();
                _mWorker = null;
                _mTimer = null;
            }
            catch (Exception){}
        }

1. T用與異步處理的時候,傳遞T類型

• 因為我們是通過.Net 的 BackgroundWorker異步模型來做的,所以我們理所當然定義相關的事件:
  1. 異步開始
  2. 異步完成
  3. 加上我們自定義擴展的異步停止
  4. ……報告進度事件在此進度條樣式中並不需要

我們先定義這四個事件所用到的參數,因為在BackgroundWorkerEx<T>泛型類中,我們還是使用BackgroundWorker來處理異步過程,因此我們定義的參數泛型類需要繼承原來的參數類型,並且在傳輸傳遞中,將原生BackgroundWorker的Argument,Result屬性轉成全局的泛型T,這樣我們在外部調用的時候,拿到的返回結果就是我們傳入到BackgroundWorkerEx<T>泛型類中的T類型,而不需要使用as進行轉換; 注:因為原生沒有停止相關事件,所以自定義異步停止的事件參數使用的是DoWorkEventArgs<T>

    public class DoWorkEventArgs<T> : DoWorkEventArgs
    {
        public new T Argument { get; set; }
        public new T Result { get; set; }
        public DoWorkEventArgs(object argument) : base(argument)
        {
            Argument = (T)argument;
        }
    }


    public class RunWorkerCompletedEventArgs<T> : RunWorkerCompletedEventArgs
    {
        public new T Result { get; set; }
        public RunWorkerCompletedEventArgs(object result, Exception error, bool cancelled) : base(result, error, cancelled)
        {
            Result = (T)result;
        }
    }

接着我們需要去定義事件,參數使用以上定義的泛型類

	public delegate void DoWorkEventHandler(DoWorkEventArgs<T> Argument);
        /// <summary>
        /// StartAsync
        /// </summary>
        public event DoWorkEventHandler DoWork;

        public delegate void StopEventHandler(DoWorkEventArgs<T> Argument);
        /// <summary>
        /// StopAsync
        /// </summary>
        public event StopEventHandler WorkStoped;

        public delegate void RunWorkCompletedEventHandler(RunWorkerCompletedEventArgs<T> Argument);
        /// <summary>
        /// FinishAsync
        /// </summary>
        public event RunWorkCompletedEventHandler RunWorkCompleted;

• 定義全局的字段
  1. private BackgroundWorker _mWorker = null;異步操作必要;
  2. private T _mWorkArg = default(T);操作傳遞進來的參數類並且返回到外部
  3. private Timer _mTimer; 定時器檢測自定義進度條控件屬性IsStop是否為true,並且動態修改進度條消息
  4. private Thread _mWorkerThread = null;異步操作在該線程中,終止時調用About()拋出ThreadAbortException異常,用於標記當前是停止而不是完成狀態
  5. private int _miWorkerStartDateSecond = 0; 異步消耗時間(非必要)
  6. private int _miShowProgressCount = 0; 動態显示”.”的個數(非必要)
  7. private ProgressbarEx _mfrmProgressForm = null; 自定義進度條控件實例

        /// <summary>
        /// .Net  BackgroundWorker
        /// </summary>
        private BackgroundWorker _mWorker = null;

        /// <summary>
        /// Whole Para
        /// </summary>
        private T _mWorkArg = default(T);

        /// <summary>
        /// Timer
        /// </summary>
        private Timer _mTimer = null;

        /// <summary>
        /// WorkingThread
        /// </summary>
        private Thread _mWorkerThread = null;

        /// <summary>
        /// Async time sec
        /// </summary>
        private int _miWorkerStartDateSecond = 0;

        /// <summary>
        /// Async time dot
        /// </summary>
        private int _miShowProgressCount = 0;

        /// <summary>
        /// ProgressbarEx
        /// </summary
        private ProgressbarEx _mfrmProgressForm = null;

• 定義全局屬性

1. IsBusy 返回_mWorker的工作忙碌是否
2. ProgressTip 自定義進度條控件显示內容

	/// <summary>
        /// Express Busy
        /// </summary>
        public bool IsBusy
        {
            get
            {
                if (_mWorker != null)
                {
                    return _mWorker.IsBusy;
                }
                return false;
            }
        }

        /// <summary>
        /// 進度條提示 默認： 正在加載數據，請稍後[{0}]{1}
        /// </summary>
        public string ProgressTip { get; set; } = "Elapsed Time[{0}]{1}";

**到現在,我們已經將必要的字段,屬性,樣式都處理完成!!! ** 接下來我們就要實現方法

※台中搬家遵守搬運三大原則,讓您的家具不再被破壞!

台中搬家公司推薦超過30年經驗,首選台中大展搬家

方法實現

• 異步工作事件,用法與BackgroundWorker一致,

  1. 如果調用處沒有註冊DoWork事件,則直接返回

  2. 將接受到的參數創建成泛型參數類

  3. 開線程,將異步操作放在該線程中操作,注意設置線程的IsBackground=true,防止主進程意外退出,線程還在處理

  4. 循環直到線程結束

  5. e.Result = Argument.Result;將結果賦予Result,在停止或者完成事件中可以獲取到結果

		/// <summary>
        /// Working
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Worker_DoWork(object sender, DoWorkEventArgs e)
        {
            if (DoWork == null)
            {
                e.Cancel = true;
                return;
            }

            DoWorkEventArgs<T> Argument = new DoWorkEventArgs<T>(e.Argument);

            try
            {
                if (_mWorkerThread != null && _mWorkerThread.IsAlive)
                {
                    _mWorkerThread.Abort();
                }
            }
            catch (Exception)
            {
                Thread.Sleep(50);
            }

            _mWorkerThread = new Thread(a =>
            {
                try
                {
                    DoWork?.Invoke(a as DoWorkEventArgs<T>);
                }
                catch (Exception)
                {

                }
            });

            _mWorkerThread.IsBackground = true;
            _mWorkerThread.Start(Argument);

            //Maybe cpu do not start thread
            Thread.Sleep(20);

            //Wait.....
            while (_mWorkerThread.IsAlive)
            {
                Thread.Sleep(50);
            }
            e.Result = Argument.Result;
        }

• 異步完成/停止

  當線程停止拋出異常(catch但是不處理)/線程完成時會進入異步完成事件

  1. 完成后,將自定義進度條控件實例關閉,釋放

1. 將全局的BackgroundWorker實例_mWorker相關事件取消註冊,並且檢查線程情況
2. 感覺線程情況,如果線程狀態為ThreadState.Aborted意味着線程被停止了,調用停止事件,否則調用完成事件

	  /// <summary>
      /// Completed
      /// </summary>
      /// <param name="sender"></param>
      /// <param name="e"></param>
      private void Worker_RunWorkCompleted(object sender, RunWorkerCompletedEventArgs e)
      {
          try
          {
              if (_mfrmProgressForm != null)
              {
                _mfrmProgressForm.Close();
                  _mfrmProgressForm.Dispose();
                _mfrmProgressForm = null;
              }

                if (_mWorker != null)
                {
                    _mWorker.DoWork -= Worker_DoWork;
                    _mWorker.RunWorkerCompleted -= Worker_RunWorkCompleted;

                    try
                    {
                        if (_mWorkerThread != null && _mWorkerThread.IsAlive) _mWorkerThread.Abort();
                    }
                    catch (Exception) { }
                }

              //In timer, When stop progress will make thread throw AbortException
              if (_mWorkerThread != null && _mWorkerThread.ThreadState == ThreadState.Aborted)
            {
                  WorkStoped?.Invoke(new DoWorkEventArgs<T>(_mWorkArg));
              }
              else
              {
                  RunWorkCompleted?.Invoke(new RunWorkerCompletedEventArgs<T>(e.Result, e.Error, e.Cancelled));
              }
          }
          catch (Exception ex)
          {
              throw ex;
          }
      }

• 線程開始

  1. 檢查消息提醒內容 , {0}{1}同於显示異步耗時和”..”的個數
  2. 在定時器執行方法中,檢查_mfrmProgressForm.IsStop是否為true,這個屬性標誌是否被停止;true則拋出異常
  3. _mfrmProgressForm不為Null則不斷修改當前的內容提醒,友好化,實際可以按需處理

  		  /// <summary>
          /// Timer Start 
          /// </summary>
          private void StartTimer()
          {
              //Check user ProgressTip
              if (!ProgressTip.Contains("{0}"))
              {
                  ProgressTip += "...Elapsed Time{0}{1}";
              }
  
              if (_mTimer != null) return;
  
              //On one sec 
              _mTimer = new Timer(1000);
              _mTimer.Elapsed += (s, e) =>
              {
                  //progress and it's stop flag (picture stop)||  this stop flag
                  if (_mfrmProgressForm != null && _mfrmProgressForm.IsStop)
                  {
                      if (_mWorker != null)
                      {
                          try
                          {
                              if (_mWorkerThread != null && _mWorkerThread.IsAlive)
                              {
                                  if (_mTimer != null && _mTimer.Enabled)
                                  {
                                      _mTimer.Stop();
                                      _mTimer = null;
                                  }
                                  _mWorkerThread.Abort();
                              }
                          }
                          catch (Exception) { }
                      }
                  }
  
                  if (_mfrmProgressForm != null)
                  {
                      //Callback 
                      _mfrmProgressForm.Invoke(new Action<DateTime>(elapsedtime =>
                      {
                          DateTime sTime = elapsedtime;
  
                          //worked time
                          _miWorkerStartDateSecond++;
                          if (_mfrmProgressForm != null)
                          {
                              _mfrmProgressForm.SetProgressValue(_miWorkerStartDateSecond);
                          }
  
                          //.....count
                          _miShowProgressCount++;
  
                          if (_miShowProgressCount > 6)
                          {
                              _miShowProgressCount = 1;
                          }
  
                          string[] strs = new string[_miShowProgressCount];
  
                          string ProgressStr = string.Join(".", strs);
  
                          string ProgressText = string.Format(ProgressTip, _miWorkerStartDateSecond, ProgressStr);
  
                          if (_mfrmProgressForm != null)
                          {
                              _mfrmProgressForm.TipMessage = ProgressText;
                          }
                      }), e.SignalTime);
                  }
              };
  
              if (!_mTimer.Enabled)
              {
                  _mTimer.Start();
              }
          }
  

• 最後一步:異步開始 與BackgroundWorker用法一致,只是在最後開始了定時器和進度條控件而已

  /// <summary>
          /// Start AsyncWorl
          /// </summary>
          /// <param name="Para"></param>
          public void AsyncStart(T Para)
          {
              //if workeven is  null ,express user do not regist event
              if (DoWork == null)
              {
                  return;
              }
  
              _miWorkerStartDateSecond = 0;
              _miShowProgressCount = 0;
  
              //init
              if (_mWorker != null && _mWorker.IsBusy)
              {
                  _mWorker.CancelAsync();
                  _mWorker = null;
              }
  
              _mWorker = new BackgroundWorker();
  
              //create progressbar
              _mfrmProgressForm = new ProgressbarEx();
  
              //add event
              _mWorker.DoWork += Worker_DoWork;
              _mWorker.RunWorkerCompleted += Worker_RunWorkCompleted;
  
              _mWorker.WorkerReportsProgress = true;
              _mWorker.WorkerSupportsCancellation = true;
  
              //Set Whole Para
              _mWorkArg = Para;
  
              _mWorker.RunWorkerAsync(Para);
              //Start timer
              StartTimer();
  
              _mfrmProgressForm.StartPosition = FormStartPosition.CenterParent;
              _mfrmProgressForm.ShowDialog();
          }
  

到這裏,整個的進度條控件已經完成了!

調用

• 定義一個參數類

	/// <summary>
    /// Para Class
    /// </summary>
    public class ParaArg
    {
        public DataTable Data { get; set; }
        public string Msg { get; set; }
        public Exception Ex { get; set; }
    }

• 定義全局的幫助類BackgroundWorkerEx<ParaArg> workHelper = null;
• 調用

				if (workHelper != null || (workHelper != null && workHelper.IsBusy))
                {
                    workHelper.Dispose();
                    workHelper = null;
                }
                if (workHelper == null)
                {
                    workHelper = new BackgroundWorkerEx<ParaArg>();
                }

                workHelper.DoWork += (eve) =>
                {
                    ParaArg args = eve.Argument;

                    try
                    { 
                        //ToDo  like Thread.Sleep(20000);
                        Thread.Sleep(10000);
                        args.Msg = "...this is bussiness code result";
                        throw new Exception("");
                    }
                    catch (Exception ex)
                    {
                        args.Ex = ex;
                    }
                    finally
                    {
                        eve.Result = args;
                    }

                };
                workHelper.RunWorkCompleted += (eve) =>
                {
                    if (eve.Error != null)
                    {
                        //get .net backgroundworker exception;
                        //handle this exception;
                        //return ?
                    }

                    //get your para result
                    ParaArg x = eve.Result;
                 
                    if (x.Ex != null)
                    {
                        //get your bussiness exception;
                        //handle this exception;
                        //return ?
                    }

                    //finially get your need;
                    //MayBe to do some UI hanlde and bussiness logical
                    string sReusltMsg = x.Msg;
                };

                workHelper.WorkStoped += (eve) =>
                { 
                    //if stoped ! it means no error;
                    //just get what you want; 
                    ParaArg x = eve.Result as ParaArg;

                    btnBegin.Enabled = true;
                };

                //參數
                ParaArg arg = new ParaArg()
                {
                    Msg = "Msg"
                };

                workHelper.AsyncStart(arg);

最後

其實不管是封裝的過程,還是調用,可以說完全就是BackgroundWorker的方式,所以很多BackgroundWorker相關的地方我都沒有很詳細的去說明;只要看看這個異步模型,就能夠很好理解!大家有空也可以實現以下,有問題也可以詳細,我比較喜歡交流技術~~~

還有一點就是這個解決方案已經放上Github上了,歡迎大家拉下來用

• GitHub地址 歡迎star/fork

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

※台中搬家公司費用怎麼算?

擁有20年純熟搬遷經驗，提供免費估價且流程透明更是5星評價的搬家公司