[转帖][c#]C＃类间通信方法初探

涉及的类有2个，一个为Provider, 负责提供信息，另一个为Master，负责接受信息。并把类间需要通信的数据封装成结构，称之为“通信结构”，记作“Information struct”。

而且，这2个类可以角色互换，互为provider。

获取信息的方式：

1、正向获取:

直接让Master访问Provider的成员。

a) Provider暴露一个成员变量或属性。 public Information GetInformation( 参数 ) ;

b) Provider暴露一个方法：这又分2种方式：一是通过中值，二是通过ref或out参数。 public int GetInformation(out Information info) ;

正向获取的主要缺点是：Master不知道何时Provider准备好了数据。

2、反向获取：

让Provider在准备好数据后，主动提供给Master。在实际使用中使用得最多的就是这种方式：在Master需要数据时，创建一个Provider object，Provider　object取得数据并作处理后，将其存入Information object中，然后将该Information object提交给Master，然后该Provider object生命周期结束，接着Master可以处理得到的数据了。

这是一个简单图书信息管理系统，图1是Master object界面，图2是Provider object界面，当点击图1的“添加”按钮时就会弹出图2所示界面，当用户填写完信息后点击“提交按钮”，即可将一个新的图书信息添加到管理系统中。

此时，Information结构可如下设计：

public struct Information
  {
     public string book_name ;
     public string author ;
     public string date ;
}

1．通过类的静态成员变量数据通信

这是最简单的直接模拟C++中的利用全局变量进行通信的方法。我们把一个Information对象作为Master的静态成员变量，并将其修饰符设为public ，那么Provider object就可以对其进行写操作，当Provider写操作完成之后，Master就可以处理静态的Information对象了。现在，问题出现了――Master怎么知道Provider完成了写操作呢？回调函数！！！――这是C++程序员的第一反应，在C#中可以吗？可以，只不过C#提供的是一种安全的函数指针，叫委托。我们前面已经指出Provider对象通常都是由Master对象创建的，那么Master对象在创建Provider对象时可以传给Provider对象一个委托实例，当Provider完成写操作之后就可以通过此委托实例完成回调了。这个过程可如图3所示。

图3 通过类的静态成员变量进行类间通信

（图略）

下面看看这种方法的主要C#伪码。

首先要定义委托：

public delegate void D_Callback() ;

再看Master类：

class Master
  {
     public static Information object_I ;
     public void GetInformation()
     {
            D_Callback callback = new D_Callback(ProcessInformation) ;
        Provider object_P = new Provider(callback) ;

//如，显示object_P界面
     }
     private void ProcessInformation()
     {

//处理object_I
}

}

接下来看看Provider如何实现：

class Provider
  {
      private D_Callback back ;
      public Provider(D_Callback yourback)  //构造函数需以“回调函数”作为参数
      {
         this.back = yourback ;
      }
      //如当用户点击图2中的“提交”按钮时，将调用以下处理函数
      private void button1_Click()
      {

  //访问Master.object_I ,并将信息写入
         back() ;//触发回调函数调用，即调用Master中的ProcessInformation函数

            this.close() ;// Provider对象完成任务,可以被GC回收了。
      }
}

}

这种方法很简单，但至少有2点问题：

1、使Information object成为Master的public 静态对象不好，因为，不仅Provider类，还有其他可能含有恶意的类都可以向其写入内容，这就丧失了安全性。

2、 Master要将自己的成员函数（作为回调的函数）包装成委托传递给Provider类作为构造函数，这就导致了Master类和Provider类非常紧密的耦合，违背了OOD基本原则。

因此再来看一个改良版本：通过堆栈对象复制进行数据通信

在Provider object中将获取数据存放到自己的私有Information object中，再由Information object调用从构造函数传递进来的委托，这样跳转到Master的回调函数时，因为Information是struct，而struct是值类型，所以将会在栈上复制这个Information object，其副本就可以被回调函数访问。这样信息就从Provider传递到Master了。

代码这样写：

public delegate void D_Callback(Information object_I) ;

//此处要将Information对象作为回调函数的参数

Code

接下来看看Provider的改变：

Code

此方法，通过堆栈object的复制避免了暴露public static member，从而增加了安全性，如此，发布事件的类根本就不必知道预定事件的类的任何情况，将以前的Master和Provider之间的循环依赖转化为单向依赖（仅仅Master依赖于Provider）。

3、通过事件机制进行通信

在Provider类中声明并发布事件，并在适当的时候触发事件，在Master类中预订事件，并定义事件的处理函数就可以了。这样，　Provider类不仅能为Master类所用，还能为其他需要此数据的类服务，可以这样认为：Master类只是Provider的一个client而已。

首先一个委托要成为事件，委托的原型声明必须这样声明：

Public delegate void D_CallBack(object sender, MyEventArgs e);

其中，MyEventArgs必须从EventArgs类继承，它是用来包装要传递的信息，在此，我们这样实现：

public class MyEventArgs:System.EventArgs
{
public Information object_I;
}

接着看看Provider是如何发布事件并触发事件的：

class Provider
  {
     public event D_Callback  PutOutInformation;  //发布事件


     private void button1_Click()
     {
            MyEventArgs  args = new MyEventArgs() ;

//将信息写入args.object_I

PutOutInformation（this，args）； //触发事件

this.close() ;

}

}

是不是简单、清晰、明了？！Provider根本就不需要知道Master类的存在。

再来看看Master类如何预定事件，以及事件发生时如何获得所需信息。

class Master
{
     public void GetInformation()
     {
          Privoder object_P = new Privoder() ;
              //预定事件
           object_P.PutOutInformation
                += new D_Callback(this.ProcessInformation) ;

..
     }
private void ProcessInformation(object sender ,MyEventArgs e)
  {

..//处理e.object_I
  }

}

本站仅提供存储服务，所有内容均由用户发布，如发现有害或侵权内容，请点击举报。