浅析.Net 在 winform及wpf中涉及界面交互的多线程类的封装

我们在开发客户端程序时，经常要用到多线程

而我们知道 ， .Net 中从线程安全的考虑，对控件改变的调用要通过Invoke， beginvoke 来进行，这就涉及怎么进行工作线程与界面的互操作。

本文以一个简单的应用为例，探讨多线程的封装性，我们的主要目的是让一个类能同时适wpf及winform对多线程的要求

现在假定程序里，有一个多线程的业务处理逻辑，如下：

//……初始化等

Thread work = new Thread(new ThreadStart(run));

work.Start();

//……其他代码



void run (){



//这里有一部分要改变界面显示的代码

} 

 

在最直观的设计中，我们是这样考虑的：

1.声明一个委托(为了从简，这里不考虑有各种参数的情况:

private void foo();

2.将用户界面交互的代码装在一个单独的函数中:

private void Foo(){

//改变界面显示

}

3.在线程中（这里先以winform为例) 用Invoke或BeginInvoke调用 这个函数

为了从简，我们只考虑Invoke

 

void run(){

//….

this.Invoke(new foo(Foo));

//….

}

现在，我们的下一步工作是要封装这个Work类，使他在其他的winform程序中也可以方便的调用。这样，我们主要有两部分工作要做：

 a.工作线程的提取

 b.界面逻辑的分割

最直接的方法是这样：

delegate void foo();

class Work{

 

private Thread work;

public Work(){

work= new Thread(new ThreadStart(run);

}

public Begin(){

work.Start();

}



public event foo Foo;



void run (){



//这里有一部分要改变界面显示的代码

if(Foo!=null)

    Foo();

} 



}

　　

这样，界面上的代码变成了这个样子：

//初始化

Work = new Work(this);

Work.Foo+= new foo(FooFunction);

Work.Begin()

到此，我们已经将多线程逻辑与界面逻辑分开了，但是现在有一个问题，就是我 要在FooFuction中调用Invoke

即

 

FooFuction(){

this.Invoke(new Foo(fooFunction));

}

fooFunction(){

//界面处理程序

}

于是，每次复用这个逻辑，我们都要反复的自己写这个Invoke ，很麻烦，于是考虑进一步的改进，即，将当前Control作为一个成员封装至Work类中，即：

 

delegate void foo();

class Work{

 private Control Owner ;

private Thread work;

public Work(Control owner){

work= new Thread(new ThreadStart(run);

Owner=owner;

}

public Begin(){

work.Start();

}



public event foo Foo;



void run (){



//这里有一部分要改变界面显示的代码

if(Foo!=null)

    if(Ownner!=null)

        Ownner.Invoke(Foo);

    else 

        Foo();

} 

}

这样，界面 上的代码就要整洁多了，现在我们不用在界面中调用 Invoke了：

 

//初始化

Work = new Work();

Work.Foo+= new foo(FooFunction);

Work.Begin()



//other code ...

 FooFuction(){

//更新界面 

}

现在，我们已经完成了一个多线程类的封闭，它有很好的封闭性和可读性，但是，新的问题来了，即，我要把它移植到 wpf程序中，本来很完美的工作类，现在他面临如下问题：

1.不与wpf程序兼容，我得自己在程序中写对应wpf的Invoke

2.运行时要依靠Control类，即我要正常使用他，还得在wpf程序中添加winform的DLL才可以

因此，我们要进行如下工作，以使我们的Work类看着很完美

1.脱离Control类的依赖

2.能同时完美的支持winform 和wpf用户程序；

显然，这里面最重要的就是要如何处理这段代码 ：

//这里有一部分要改变界面显示的代码

if(Foo!=null)

    if(Ownner!=null)

        Ownner.Invoke(Foo);

    else 

        Foo();

考虑到我们对Control的引用 只是为了调用它的Invoke ,于是，可以将Invoke提一个接口 ：

interface  IWorkHost{

void Invoke (delegate method);

public object Parent;

}

这样，我们只需将Work类中的Owner 从Control变为IWorkHost，其他代码不用改变，剩下的工作就好办了：

我们可以把对windows.forms 引用从Work所在的工程移掉，然后，加一个DLL工程WinformHost ,引用 Work类所在工程

声明一个类WinformHost来实现IWorkHost

class WinformHost:IWorkHost{

private Control parent;

public object Parent{get{return parent;}}

public WinformHost(Control parent){

parent = parent;

}

public void Invoke (delegate method){

parent.Invoke(method);

}

类似的，增加用于WPF的WPFWorkHost

class WPFHost:IWorkHost{

private Dispatcher parent;

public object Parent{get{return parent;}}

public WPFHost(Control parent){

parent = parent;

}

public void Invoke (delegate method){

parent.Invoke(method);

}

这样，当在winform中使用Work类时，代码变成：

Work = new Work(new WinformHost(this));
Work.Foo+= new foo(FooFunction);
Work.Begin()

当在 wpf程序中使用 work类时，代码变成：

 

Work = new Work(new WPFHost(this.dispatcher));
Work.Foo+= new foo(FooFunction);
Work.Begin()

总结：

我们在这个文章里依次做了如下的工作：

1.将一个多线程的逻辑加到winform中

2.将这个多线程封装到单独的类

3.改进这个逻辑使他同时适应winform和wpf

这里用到到模式，应该是适配器模式，其实这个应用场景和很多复用封装的场景相类似，只不过多线程在 winform和wpf中是经常讨论的问题，用这个问题来解释这种封装，我觉得会好一些。

文笔不好，见谅。