c#中winform的MVP模式的简单实现

MVP模式是类似于MVC模式的一种设计模式，最近在做项目学习过程中遇到，弄了很久终于有一些眉目，这是学习过程中的一些笔记。
MVP指的是实体对象Model、视图Viw和业务处理Presenter。MVP的作用是解耦UI渲染、业务逻辑和数据实体的关系。在普通的winform中，业务和界面是写在一起的，一般都是同一个Load或Click方法中，使View和Controller紧密联系。在MVP中，我们将界面渲染放在View里面，也就是winfrom的窗体应用类；将业务关系放在Presenter类中，这就是MVP中的业务数据类；最后的数据实体与数据库的交互放在Model中，是三者各司其职。
一般的MVP中，我们是在Presenter中主动使用View，也就是界面控件形态都是由Presenter去主动控制的。而建立这两者之间的联系，就是在Presenter中注册View的事件，当界面发生由用户触发事件时，这个事件会通过View传递到Presenter中，并在Presenter中调用Model的数据方法，最后Presenter调用在类中引用的View的实例去改变界面形态，下面是一些方法的实现，这里着重说明Presenter和View的关系。
首先，我们定义View的接口类IView，里面就一个数据实体的引用：

 public interface IView<T>:IView
 {
     T Model { get; set; }
 }

public interface IView:IView

接下来，定义View的下一级接口，这里是定义视图一些控件和事件：

 public interface IMainForm<T> : IView<T>
 {
     Button TestButton { get;}    //定义MainFrom的按钮引用
     TextBox TestTextBox { get; }    //定义MianForm的文本框引用
     event EventHandler ViewLoadEvent;    //定义窗体加载完毕执行事件
     event EventHandler ButtonSubmitEvent;    //定义按钮事件
     void ShowSubmitDialog();    //定义自定义的事件
 }

public interface IMainForm : IView

最后就是View的实现类，里面是实现的接口方法和属性，包含一个按钮及一个文本框，这里有一个继承了的MvpForm类和PresenterBinding的特性，一会再说：

 [PresenterBinding(typeof(MainFormPresenter))]
 public partial class MainForm : MvpForm , IMainForm<MainFormModel>
 {
     public MainForm()
     {
         InitializeComponent();
     }
 
     public MainFormModel Model { get; set; }
     public TextBox TestTextBox { get { return txtText; } }
     public Button TestButton { get { return btnSubmit; } }
 
     public event EventHandler ViewLoadEvent;
     public event EventHandler ButtonSubmitEvent;
 
     private void MainForm_Load(object sender, EventArgs e)
     {
         if (ViewLoadEvent != null) ViewLoadEvent(sender, e);
     }
 
     public void ShowSubmitDialog()
     {
         MessageBox.Show("to submit?");
     }
 
     private void btnSubmit_Click(object sender, EventArgs e)
     {
         if (ButtonSubmitEvent != null) ButtonSubmitEvent(sender , e);
     }
 }

public partial class MainForm : MvpForm , IMainForm

定义完View的内容，就可以看一下Presenter，同样，先有接口，再有实现，先定义Presenter的接口：

 public interface IPresenter<T>:IPresenter where T : class, View.IView
 {
     T View { get; }
 }

public interface IPresenter:IPresenter where T : class, View.IView

这里再定义一个Presenter的抽象类，用于统一各个不同View对应的Presenter类，其定义如下：

 public abstract class Presenter<T> : IPresenter<T> where T : class, View.IView
 {
     private readonly T view;
 
     //这里的view作为引用，用于在presenter中获取View的实例
     protected Presenter(T view)
     {
     this.view = view;
     }
 
     public T View { get { return view; } }
 }

public abstract class Presenter : IPresenter where T : class, View.IView

最后就是对应的View的Presenter类了：

 class MainFormPresenter:Presenter<View.IMainForm<Model.MainFormModel>>
 {
     public MainFormPresenter(View.IMainForm<Model.MainFormModel> view)
 : base(view)
     {
     view.Model = new Model.MainFormModel();
 
     view.ViewLoadEvent += On_ViewLoad;
     view.ButtonSubmitEvent += On_ButtonSubmitClick;
     init();
     }
 
     public void init()
     {
         //To Do something...
     }
 
     public void On_ViewLoad(object sender, EventArgs e)
     {
         //To Do something...
     }
 
     public void On_ButtonSubmitClick(object sender, EventArgs e)
     {
         View.ShowSubmitDialog();//通过view的实例调用view的方法来改变控件形态
     }
 }

class MainFormPresenter:Presenter<View.IMainForm>

这里定义了Presenter和View的接口和实现，下面就是如何将这两个不同的模块联合在一起，这里，使用的是.net的特性和反射。
首先，先建立特性类PresenterBindingAttribute，通过在View的实现类标记该特性类和指定对应的Presenter类，就可以获取View和Presenter的对应关系了,该类同样要标注特性AttributeUsage和继承Attribute类，同时定义两个属性参数：

 [AttributeUsage(AttributeTargets.Class,AllowMultiple = true)]
 public sealed class PresenterBindingAttribute : Attribute
 {
     public Type PresenterType { get;private set; }
 
     public Type ViewType { get; set; }
 
     public PresenterBindingAttribute(Type presenterType)
     {
         PresenterType = presenterType;
         ViewType = null;
     }
 }

public sealed class PresenterBindingAttribute : Attribute

接下来，就是通过反射去建立view和presenter的关系，这里建立PerformBinding类：

 public IPresenter PerformBinding(IView viewInstance)
 {
     IPresenter presenter = null;
     Type t = viewInstance.GetType();    //获取该视图的类类型
     object[] attrs = t.GetCustomAttributes(typeof(PresenterBindingAttribute), false);    //获取该类上的附加特性集合
     //遍历特性集合，找到Presenter类型附加的特性，通过该特性建立实例
     foreach (PresenterBindingAttribute pba in attrs)
     {
         Type newt = pba.PresenterType;    //获取Presenter类类型
         //建立Presenter实例，这里的构造参数是View的对象，这样就使两者建立了联系
         Object obj = Activator.CreateInstance(pba.PresenterType, viewInstance);
         presenter = obj as IPresenter;
     }
     return presenter;
 }

public IPresenter PerformBinding(IView viewInstance)

那么，这个类PerformBinding在哪里使用，一般是在应用View启动是就要注册实例，这里为了解除类间的强耦合，就添加一个中间类。在前面的View的实现类中，是继承自一个MvpForm的类，这个MvpForm就使注册View和Presenter关系的类，接下来看MvpForm的实现：

 public partial class MvpForm : Form,IView
 {
     private readonly PresenterBinder presenterBinder = new PresenterBinder();
     public MvpForm()
     {
         presenterBinder.PerformBinding(this);    //注册关系
     }
 }

public partial class MvpForm : Form,IView

这样，就建立了View与Presenter之间的关系，每次View页面启动，就先执行父类MvpForm的构造函数，注册View和Presenter的关系，相应的逻辑可以写在Presenter中，View的作用就是作为UI的渲染。以后添加View和Presenter实现类时，只需要继承和实现相应的类和接口，并在View实现类添加相应的对应类特性，就可实现MVP的设计关系。