设计模式之 迪米特法则

定义：如果两个类不必彼此通信，那么这两个类就不应该发生直接的相互作用。如果其中一个类需要调用另一个类的某个方法，可以通过第三者转发这个调用。其本意是，设计中要注意松耦合。
    这个很好理解，如果类和类之间没什么联系就不说了。但是如果类之间有联系，比如类1要调用类2的方法或属性，不能说我在类1中引用类2，然后利用类2的引用调用类2的属性或方法。正确的处理是用委托或事件。这样减少类的耦合。下面拿例子说明。
比如有两个窗体Form1和Form2，Form2有一个button，当点击button的时候Form1显示一句话。不按照迪米特法则的实现：

Form1图：

1. public partial class Form1 : Form  
2. {  
3.     public Form1()  
4.     {  
5.         InitializeComponent();  
6.     }  
7.     private void button1_Click(object sender, EventArgs e)  
8.     {  
9.         Form2 form2 = new Form2(this);  
10.   
11.         form2.ShowDialog(this);  
12.     }  
13. }  

Form2中定义了Form1的引用。

[csharp] view plain copy print ?

1. public partial class Form2 : Form  
2. {  
3.     public Form2()  
4.     {  
5.         InitializeComponent();  
6.     }  
7.   
8.     private Form1 form1;  
9.   
10.     public Form2(Form1 form1)  
11.     {  
12.         InitializeComponent();  
13.   
14.         this.form1 = form1;  
15.     }  
16.   
17.     private void button1_Click(object sender, EventArgs e)  
18.     {  
19.         form1.richTextBox1.Text = "Form2的消息";  
20.     }  
21. }  

 运行，点击Form1的button，Form2窗口显示出来，再点击Form2的button，Form1的richtextbox1内容为："Form2的消息"。

 这样也实现了要求。这样的话为了使Form2中能访问到Form1的richtextbox1，必须要把richtextbox1定义成Public。richtextbox1是Form1的私有成员，一旦公布出来破坏了封装性。而且假如，在软件发布后，决定不要Form1了，又新建另一个FormNew显示Fom2，那么就要去删掉Form1的同时还要再打开Form2，重新定义一个FormNew的引用。改动太多，不符合开放封闭原则。
 那么修改它，按照迪米特法则修改。通过第三者转发这个调用，我们利用事件来完成。修改代码如下：
 增加一个传递的类：

[csharp] view plain copy print ?

1.  public class MessageEventArgs:EventArgs  
2. {  
3.     private string messageString = string.Empty;  
4.   
5.     public MessageEventArgs(string message)  
6.     {  
7.         this.messageString = message;  
8.     }  
9.   
10.     public string MessageString  
11.     {  
12.         get  
13.         {  
14.             return messageString;  
15.         }  
16.     }  
17. }  

Form2中定义事件

[csharp] view plain copy print ?

1. public partial class Form2 : Form  
2. {  
3.     public event EventHandler<MessageEventArgs> ShowMessageEventHandler;  
4.   
5.     public Form2()  
6.     {  
7.         InitializeComponent();  
8.     }  
9.   
10.     //private Form1 form1;  
11.   
12.     //public Form2(Form1 form1)  
13.     //{  
14.     //    InitializeComponent();  
15.   
16.     //    this.form1 = form1;  
17.     //}  
18.   
19.     //private void button1_Click(object sender, EventArgs e)  
20.     //{  
21.     //    form1.richTextBox1.Text = "Form2的消息";  
22.     //}  
23.   
24.     private void button1_Click(object sender, EventArgs e)  
25.     {  
26.         if (this.ShowMessageEventHandler != null)  
27.         {  
28.             ShowMessageEventHandler(this, new MessageEventArgs("Form2的消息"));  
29.         }  
30.     }  
31. }  

 Form1注册这个事件，并绑定方法。

[csharp] view plain copy print ?

1.  public partial class Form1 : Form  
2. {  
3.     public Form1()  
4.     {  
5.         InitializeComponent();  
6.     }  
7.     private void button1_Click(object sender, EventArgs e)  
8.     {  
9.         Form2 form2 = new Form2();  
10.   
11.         form2.ShowMessageEventHandler += new EventHandler<MessageEventArgs>(form2_ShowMessageEventHandler);  
12.   
13.         form2.ShowDialog(this);  
14.   
15.         //Form2 form2 = new Form2(this);  
16.   
17.         //form2.ShowDialog(this);  
18.     }  
19.   
20.     void form2_ShowMessageEventHandler(object sender, MessageEventArgs e)  
21.     {  
22.         this.richTextBox1.Text = e.MessageString;  
23.     }  
24. } 
    

显然，后者的耦合性大大降低，即使删除掉Form1，要改用另一个FormNew，不用去改动Fom2，只需在FomrNew中重新注册事件，并绑定方法就可以了。也增强了Form2的复用性。一举多得何乐而不为。