android 和 ios中实现类似C#的BackgroundWorker接口

移动应用为支持各种功能，大多采用了多线程技术。使用单独的线程执行某些任务，同时不影响界面的刷新，在线程执行过程中，可能需要通知一些信息给界面线程，在线程结束之后，需要告诉界面线程执行的结果，这是较为通用的一种线程执行方式。

    在C#中，实现该功能的类是BackgroundWorker, 而在android和ios中，并无类似的封装好的类。通常在开发应用的时候需要考虑可移植性，存在为多种平台开发相同应用的情况，为简化不同平台应用的开发，编程需要考虑相同的逻辑结构。因此在android和ios实现与BackgroundWorker类似的功能和接口。

1.C#的BackgroundWorker

    BackgroundWorker包含的主要属性和接口说明如下：

    主要属性:

    event DoWorkEventHandler DoWork;  //线程的主体
    event ProgressChangedEventHandler ProgressChanged;  //线程运行过程中的消息
    event RunWorkerCompletedEventHandler RunWorkerCompleted; //线程结束时的处理

    主要函数：

    void CancelAsync();  取消线程的运行
    void ReportProgress(int percentProgress, object userState);  //报告线程的消息
    void RunWorkerAsync(object argument);  //开始执行线程

    为了方面使用，可以将BackgroundWorker进行封装如下

   

    public class StarBackgroundWorker
    {
        private BackgroundWorker m_worker;
        public StarBackgroundWorker()
        {
            m_worker = new BackgroundWorker();
        }
        public void CancelAsync()
        {
            m_worker.CancelAsync();
        }
        public void RunAsync(DoWorkEventHandler DoWork, object userState, ProgressChangedEventHandler ProgressChanged, RunWorkerCompletedEventHandler RunWorkerCompleted)
        {
            m_worker.DoWork += DoWork;
            m_worker.WorkerSupportsCancellation = true;
            m_worker.RunWorkerCompleted += RunWorkerCompleted;
            if (ProgressChanged != null)
            {
                m_worker.ProgressChanged += ProgressChanged;
                m_worker.WorkerReportsProgress = true;
            }
            m_worker.RunWorkerAsync(userState);
        }
        public void ReportProgress(int percentProgress, object userState)
        {
            m_worker.ReportProgress(percentProgress, userState);
        }
    }

    使用方法：

StarCoreBackgroundWorker myworker = new StarCoreBackgroundWorker();
myworker.RunAsync(
    (object sender1, DoWorkEventArgs e1) =>
    {
        BackgroundWorker worker = sender1 as BackgroundWorker;
        //线程的主体
    },
    null,
    (object sender1, ProgressChangedEventArgs e1) =>
    {
        //--在界面线程中执行，可以刷新界面
    },
    (object sender1, RunWorkerCompletedEventArgs e1) =>
    {
        //--在界面线程中处理，线程运行结束后的处理
    }
);

2.Android中实现类似BackgroundWorker的功能

Android中使用java编程，通常创建线程使用Thread和Runnable，线程与界面线程通信使用消息的方式，从界面线程中的handler获取一条消息结构，填充参数，使用sendMessage将消息发送给界面线程。界面线程的Handler获取消息队列中的消息进行处理。利用这些方式，可以实现类似c# BackgroundWorker功能

a. 封装Handler

    由于采用Handler处理所有BackgroundWorker线程中的消息，为了区分不同的线程，需要线程在创建时进行登记。代码如下：

public class StarUIHander {
    static public Handler handler;
    static int InvokeTag = 0;
    static HashMap<Integer,HandlerCallBack> CallBackList;
    public interface HandlerCallBack {
        void Invoke(Message msg);
    }
    static int Register(HandlerCallBack CallBack)
    {
        int Val = InvokeTag;
        CallBackList.put(InvokeTag,CallBack);
        InvokeTag ++;
        return Val;
    }

    static void Remove(int Which)
    {
        CallBackList.remove(Which);
    }

    static void InitStarUIHander()
    {
        handler = new android.os.Handler() {
            public void handleMessage(Message msg) {
                HandlerCallBack CallBack = CallBackList.get(msg.what);
                if( CallBack != null )
                    CallBack.Invoke(msg);
            }
        };
        CallBackList = new HashMap<Integer,HandlerCallBack>();
    }
}

    在android应用主Activity中，调用InitStarUIHander初始化Handler，对于创建的线程，调用Register注册消息处理函数，获取标识，使用该标识发送消息时。

b. 实现BackgroundWorker功能

    在实现BackgroundWorker之前，参照c#的定义，需要实现一些相关的接口。有以下几个：
    CancellationTokenSource, ProgressChangedEventArgs, DoWorkEventArgs，RunWorkerCompletedEventArgs，具体代码可参考附件

   

public BackgroundWorker()
{
    //_dispatcher = this.Dispatcher;
    cts = new CancellationTokenSource();
    HandlerQueue = StarUIHander.Register(new StarUIHander.HandlerCallBack() {
        @Override 
        public void Invoke(Message msg) {
            Object[] Para = (Object[])msg.obj;
            switch ((int)Para[0]) {
            case Message_ReportProgress:
                if (ProgressChanged != null ){
                    ProgressChanged.Invoke(this,(ProgressChangedEventArgs)Para[1]);
                }
                break;
            case Message_OnRunWorkerCompleted:
                if (RunWorkerCompleted != null)
                    RunWorkerCompleted.Invoke(this,(RunWorkerCompletedEventArgs)Para[1]);
                break;
            }
        }
    });
}

    报告状态:

public void ReportProgress(int percentProgress, Object userState)
{
    if (ProgressChanged != null ){
        Message message = StarUIHander.handler.obtainMessage();
        message.what = HandlerQueue;
        message.obj = new Object[]{Message_ReportProgress,new ProgressChangedEventArgs(percentProgress,userState)};
        StarUIHander.handler.sendMessage(message);
    }
}

    创建线程执行:

public void RunWorkerAsync(Object userState)
{
    final BackgroundWorker m_worker = this;
    if (DoWork != null)
    {
        IsBusy = true;
        try {
            final DoWorkEventArgs args = new DoWorkEventArgs(userState);
            new Thread(new Runnable(){
                @Override
                public void run() {
                    DoWork.Invoke(m_worker, args);
                    IsBusy = false;
                    if (RunWorkerCompleted != null) {
                        Message message = StarUIHander.handler.obtainMessage();
                        message.what = HandlerQueue;
                        message.obj = new Object[]{Message_OnRunWorkerCompleted, new RunWorkerCompletedEventArgs(args.Result, null, args.Cancel)};
                        StarUIHander.handler.sendMessage(message);
                    }
                }
            }).start();
        }
        catch (Exception ex) {
            IsBusy = false;
            if (RunWorkerCompleted != null) {
                Message message = StarUIHander.handler.obtainMessage();
                message.what = HandlerQueue;
                message.obj = new Object[]{Message_OnRunWorkerCompleted, new RunWorkerCompletedEventArgs(false, ex, false)};
                StarUIHander.handler.sendMessage(message);
            }
        }
    }
}

     为了方面使用，将BackgroundWorker进行封装如下

    public static class StarCoreBackgroundWorker
    {
        private BackgroundWorker m_worker;
        public StarCoreBackgroundWorker()
        {
            m_worker = new BackgroundWorker();
        }
        public void CancelAsync()
        {
            m_worker.CancelAsync();
        }
        public void RunAsync(DoWorkEventHandler DoWork, Object userState, ProgressChangedEventHandler ProgressChanged, RunWorkerCompletedEventHandler RunWorkerCompleted)
        {
            m_worker.DoWork = DoWork;
            m_worker.WorkerSupportsCancellation = true;
            m_worker.RunWorkerCompleted = RunWorkerCompleted;
            if (ProgressChanged != null)
            {
                m_worker.ProgressChanged = ProgressChanged;
                m_worker.WorkerReportsProgress = true;
            }
            m_worker.RunWorkerAsync(userState);
        }
        public void ReportProgress(int percentProgress, Object userState)
        {
            m_worker.ReportProgress(percentProgress, userState);
        }
    }

    使用方法：

StarBackgroundWorker myworker = new StarBackgroundWorker();
myworker.RunAsync(
        new DoWorkEventHandler() {
            public void Invoke(Object sender1, DoWorkEventArgs e1) {
                BackgroundWorker worker = sender1 as BackgroundWorker;
                //线程的主体
            }
        },
        null,
        new ProgressChangedEventHandler() {
            public void Invoke(Object sender1, ProgressChangedEventArgs e1) {
                //--在界面线程中执行，可以刷新界面
            }
        },
        new RunWorkerCompletedEventHandler() {
            public void Invoke(Object sender, RunWorkerCompletedEventArgs e) 
            {
                //--在界面线程中处理，线程运行结束后的处理
            }
       });

3. ios中实现类似BackgroundWorker的功能

    ios创建线程可以使用NSThread，在界面线程中运行调用performSelectorOnMainThread函数；也可以使用GCD相关的函数，对多线程进行封装，可以实现类似c#的BackgroundWorker功能

a. 实现BackgroundWorker功能

    与android类似，在实现BackgroundWorker之前，参照c#的定义，同样需要实现一些相关的接口。有以下几个：
CancellationTokenSource, ProgressChangedEventArgs, DoWorkEventArgs，RunWorkerCompletedEventArgs，具体代码可参考附件

    定义接口:

typedef void(^ProgressChangedEventHandler)(id,ProgressChangedEventArgs*);
typedef void(^RunWorkerCompletedEventHandler)(id,RunWorkerCompletedEventArgs*);
typedef void(^DoWorkEventHandler)(id,DoWorkEventArgs*);

    实现BackgroundWorker

    上报状态:

-(void)ReportProgress:(uint)percentProgress userState:(id)userState
{
    if (ProgressChanged != nil || ProgressChangedSelector != nil ){
        dispatch_async(dispatch_get_main_queue(),^{
            @try{
                if( ProgressChangedSelector == nil )
                    ProgressChanged(self,[ProgressChangedEventArgs initProgressChangedEventArgs:percentProgress UserState:userState]);
                else{
                    IMP imp = [SelectorController methodForSelector:ProgressChangedSelector];
                    void (*func)(id, SEL, id, ProgressChangedEventArgs* ) = (void *)imp;
                    func(SelectorController, ProgressChangedSelector, self, [ProgressChangedEventArgs initProgressChangedEventArgs:percentProgress UserState:userState]);
                }
            }
            @catch(NSException* e)
            {
                
            }
        });
    }
}

    异步执行

-(void)RunWorkerAsync:(id)userState
{
    if (DoWork != nil || DoWorkSelector != nil)
    {
        @try {
            DoWorkEventArgs* args = [DoWorkEventArgs initDoWorkEventArgs:userState];
            dispatch_async(dispatch_get_global_queue(0, 0),^{
                if( DoWork != nil )
                    DoWork(self,args);
                else if(DoWorkSelector != nil ){
                    IMP imp = [SelectorController methodForSelector:DoWorkSelector];
                    void (*func)(id, SEL, id, DoWorkEventArgs* ) = (void *)imp;
                    func(SelectorController, DoWorkSelector, self,args);
                }
                dispatch_async(dispatch_get_main_queue(),^{
                    if (RunWorkerCompleted != nil)
                        RunWorkerCompleted(self,[RunWorkerCompletedEventArgs initRunWorkerCompletedEventArgs:args.Result Cancelled:args.Cancel]);
                    else if(RunWorkerCompletedSelector != nil){
                        IMP imp = [SelectorController methodForSelector:RunWorkerCompletedSelector];
                        void (*func)(id, SEL, id, RunWorkerCompletedEventArgs* ) = (void *)imp;
                        func(SelectorController, RunWorkerCompletedSelector, self,[RunWorkerCompletedEventArgs initRunWorkerCompletedEventArgs:args.Result Cancelled:args.Cancel]);
                    }
                });
            });
        }
        @catch(NSException* e)
        {
            dispatch_async(dispatch_get_main_queue(),^{
                if (RunWorkerCompleted != nil)
                    RunWorkerCompleted(self,[RunWorkerCompletedEventArgs initRunWorkerCompletedEventArgs:e]);
                else if( RunWorkerCompletedSelector != nil ){
                    IMP imp = [SelectorController methodForSelector:RunWorkerCompletedSelector];
                    void (*func)(id, SEL, id, RunWorkerCompletedEventArgs* ) = (void *)imp;
                    func(SelectorController, RunWorkerCompletedSelector, self,[RunWorkerCompletedEventArgs initRunWorkerCompletedEventArgs:e]);
                }
            });
        }
    }
}

 

b. 为了方面使用，将BackgroundWorker进行封装如下

-(void)RunAsync:(DoWorkEventHandler)DoWork userState:(id)userState ProgressChanged:(ProgressChangedEventHandler)ProgressChanged RunWorkerCompleted:(RunWorkerCompletedEventHandler)RunWorkerCompleted
{
    m_worker.DoWork = DoWork;
    m_worker.RunWorkerCompleted = RunWorkerCompleted;
    if (ProgressChanged != nil)
    {
        m_worker.ProgressChanged = ProgressChanged;
    }
    [m_worker RunWorkerAsync:userState];
}

-(void)ReportProgress:(uint)percentProgress userState:(id)userState
{
    [m_worker ReportProgress:percentProgress userState:userState];
}

使用方法：

StarBackgroundWorker* myworker = [StarBackgroundWorker initStarBackgroundWorker];
            [myworker RunAsync:^(id sender1, DoWorkEventArgs *e) {
                BackgroundWorker* worker = (BackgroundWorker*)sender1;
                
            } userState:nil ProgressChanged:^(id sender1, ProgressChangedEventArgs *e) {

            } RunWorkerCompleted:^(id sender1, RunWorkerCompletedEventArgs *e) {

            }
            }];

4. 结束语

    如果不考虑可移植性，可以直接使用android，ios，windows中定义的多线程方法开发应用，但由于不同平台采用的是不同语言，多线程实现接口和方式不同，会影响应用的逻辑结构，增加不同平台移植的工作量。基于线程执行过程，参考C#中的BackgroundWorker机制，在android和ios实现了类似的多线程机制，采用相同的框架结构，提供类似的接口，可以使多线程在不同平台具有相同的逻辑结构

    上面的代码不完整，具体请参考附件

下载附件