.NET程序员应该熟悉的开发模式

我们总会有这样一个经验：一个系统最不容易也最不应该变化的部分是领域逻辑，最容易变化也最应该变化的是数据的呈现方式。

创新互联公司2013年成立，是专业互联网技术服务公司，拥有项目网站设计、网站建设网站策划，项目实施与项目整合能力。我们以让每一个梦想脱颖而出为使命，1280元五峰做网站,已为上家服务,为五峰各地企业和个人服务,联系电话:13518219792

在Java的各种应用中可以说是到处可见MVC，J2EE贯穿MVC的概念，android的开发方式也是类MVC的，MVC结构对于做过Java应用的人而言简直就是司空见惯。而在.NET这边，由于之前微软为大家提供的各种winform、ASP.NET项目典范（比如那个petshop series）将“三层”概念很好的灌输到了.NET程序员的大脑中，许多.NET开发者凡是做个东西都要搬出自己最拿手的IModel、IDAL这样的神器。

其实MVC与所谓的“三层架构”是两个层次上的东西，前者是一种结构模式，而后者则是分层的角度去说。

一件很奇怪的事情，许多人知道“三层”却不知道MVC，其实这要归结与.NET的早期开发技术ASP.NET和winform这些page controller的典范让许多人对三层夸夸其谈却对MVC视而不见甚至一无所知。什么是page controller模式呢？搞.NET的大多都用过winform和webform，这种xxxform用起来很直观，我们想要做一个程序，ok，最简单的方式就是拖拖拽拽几个控件，然后在一个叫code behind的东西里写这些UI事件的处理逻辑，加一大堆变量用于记录数据和状态，这样一个程序就能出炉。这种开发方式对于一些小软件系统的开发其实效率还是蛮高的，后来人们看到其弊端---一旦修改UI，事件处理就要跟着变，但是业务还是那个业务，凭什么要修改非UI的代码？于是有人提出“三层”，最朴素的理解就是将原本那堆事件处理里的code分成业务代码和数据库访问代码并转移到其它类中，做多了就把那坨UI叫做UI，那坨业务代码叫做BLL，那坨DAO叫做DAL。也就是这种架构：

而对于J2EE的开发者来说熟悉的是下图。 

（说明：这两幅图copy自是daxnet文）

MVC是什么

MVC是一个很经典的结构，并且其又其思想衍生出很多变种比如MVP,MVVP。传统的MVC结构之一是这样的（拿主动型MVC来说）：

比如web开发（比如ASP.NET MVC或者是Java的web开发方式）,view就是纯web页面或者webservice，当提交一个表单/调用webservice或者ajax后会将数据提交给controller（当然期间可能会经过各种filterchain、listener这样的东西）controller调用相应的业务模块来处理这个请求，最终结果会更新View的显示。

MVP

对于非天然MVC的框架

对于ASP.NET/winform而言，虽然可以通过改造让其支持MVC结构的开发（比如通过定制IHttpModule、IHttpHandler云云），但是在企业看来这些都算是邪门武功（因为这样会丧失xxxform在开发上的很多特性比如快速开发）。大多数使用的是mvp模式。什么是mvp呢？其实mvp是MVC的一个变种。因为用winform或者webform的话form始终是个阻碍MVC开发的问题。那么好，我们仍然使用designer和codebehind，其实一个架构设计的好坏是取决于人而不是具体的技术的，只要我们OO一时强page controller一样好用。

在MVP模式中我们需要自己定制各个View（web页面或者窗体）对应的IView和IPresenter、IModel。IView要对IPresenter暴露操作UI、数据绑定的接口，IPresenter对IView要暴露当UI事件触发需要调用的接口，IPresenter根据IView传递过来的请求调用业务接口并根据结果操作UI。举个简单的例子，一个计算“x+y=?”的程序。如果我们这样定义IPresenter和IView

 
 
 
 
    
  
  
  
  
  1. public interface IPresenter   
    2. 
  
  
  
  
  2.     {   
    3. 
  
  
  
  
  3.         IView View { get; set; }   
    4. 
  
  
  
  
  4.         void CalculateResult();   
    5. 
  
  
  
  
  5.     }  
    6. 
  
  
  
  
  6.  
    7. 
  
  
  
  
  7. public interface IView   
    8. 
  
  
  
  
  8.     {   
    9. 
  
  
  
  
  9.         IPresenter Presenter { get; set; }   
    10. 
  
  
  
  
  10.         void ShowResult(string result);   
    11. 
  
  
  
  
  11.         int ValueOne { get; }   
    12. 
  
  
  
  
  12.         int ValueTwo { get; }   
    13. 
  
  
  
  
  13.     } 
    14.

IPresenter的实现如下（这里从简把IModel去掉了）

Presenter

  
 
 
 
    
   
  
  
  
  1. namespace ClientLibrary  
    2. 
   
  
  
  
  2. {  
    3. 
   
  
  
  
  3.     public class Presenter : IPresenter  
    4. 
   
  
  
  
  4.     {  
    5. 
   
  
  
  
  5.         private IView _view;  
    6. 
   
  
  
  
  6.         public IView View  
    7. 
   
  
  
  
  7.         {  
    8. 
   
  
  
  
  8.             get 
    9. 
   
  
  
  
  9.             {  
    10. 
   
  
  
  
  10.                 return _view;  
    11. 
   
  
  
  
  11.             }  
    12. 
   
  
  
  
  12.             set 
    13. 
   
  
  
  
  13.             {  
    14. 
   
  
  
  
  14.                 _view = value;  
    15. 
   
  
  
  
  15.                 _view.Presenter = this;  
    16. 
   
  
  
  
  16.             }  
    17. 
   
  
  
  
  17.         }  
    18. 
   
  
  
  
  18.  
    19. 
   
  
  
  
  19.         private static readonly string RESULT_FORMATTER = "{0}+{1},the result is {2}";  
    20. 
   
  
  
  
  20.         public void CalculateResult()  
    21. 
   
  
  
  
  21.         {  
    22. 
   
  
  
  
  22.             if (_view != null)  
    23. 
   
  
  
  
  23.             {  
    24. 
   
  
  
  
  24. var result = string.Format(RESULT_FORMATTER, _view.ValueOne, _view.ValueTwo, _view.ValueOne + _view.ValueTwo);  
    25. 
   
  
  
  
  25.                 _view.ShowResult(result);  
    26. 
   
  
  
  
  26.                 this.A = 123;  
    27. 
   
  
  
  
  27.             }  
    28. 
   
  
  
  
  28.         }  
    29. 
   
  
  
  
  29.         private int _a;  
    30. 
   
  
  
  
  30.         public int A  
    31. 
   
  
  
  
  31.         {  
    32. 
   
  
  
  
  32.             set 
    33. 
   
  
  
  
  33.             {  
    34. 
   
  
  
  
  34.                 A = value;  
    35. 
   
  
  
  
  35.             }  
    36. 
   
  
  
  
  36.         }  
    37. 
   
  
  
  
  37.     }  
    38. 
   
  
  
  
  38. } 
    39.

View的实现如下（那silverlight为例，换成别的也行）

MainPage

  
 
 
 
    
   
  
  
  
  1. namespace debug  
    2. 
   
  
  
  
  2. {  
    3. 
   
  
  
  
  3.     public partial class MainPage : UserControl, IView  
    4. 
   
  
  
  
  4.     {  
    5. 
   
  
  
  
  5.         public MainPage()  
    6. 
   
  
  
  
  6.         {  
    7. 
   
  
  
  
  7.             InitializeComponent();  
    8. 
   
  
  
  
  8.         }  
    9. 
   
  
  
  
  9.  
    10. 
   
  
  
  
  10.         private IPresenter _presenter;  
    11. 
   
  
  
  
  11.  
    12. 
   
  
  
  
  12. private void btn_Click(object sender, RoutedEventArgs e)  
    13. 
   
  
  
  
  13.         {  
    14. 
   
  
  
  
  14.             if (_presenter != null)  
    15. 
   
  
  
  
  15.             {  
    16. 
   
  
  
  
  16.                 _presenter.CalculateResult();  
    17. 
   
  
  
  
  17.             }  
    18. 
   
  
  
  
  18.             #region hidden  
    19. 
   
  
  
  
  19.             /*int total = 0;  
    20. 
   
  
  
  
  20.             try  
    21. 
   
  
  
  
  21.             {  
    22. 
   
  
  
  
  22. total = int.Parse(tb1.Text) + int.Parse(tb2.Text);  
    23. 
   
  
  
  
  23. MessageBox.Show("计算结果：" + total.ToString());  
    24. 
   
  
  
  
  24.             }  
    25. 
   
  
  
  
  25.             catch (Exception ex)  
    26. 
   
  
  
  
  26.             {  
    27. 
   
  
  
  
  27.                 MessageBox.Show("出错啦" + ex.ToString());  
    28. 
   
  
  
  
  28.             }  
    29. 
   
  
  
  
  29.             finally  
    30. 
   
  
  
  
  30.             {  
    31. 
   
  
  
  
  31.                 tb1.Text = string.Empty;  
    32. 
   
  
  
  
  32.                 tb2.Text = string.Empty;  
    33. 
   
  
  
  
  33.             }*/ 
    34. 
   
  
  
  
  34.             #endregion  
    35. 
   
  
  
  
  35.  
    36. 
   
  
  
  
  36.         }  
    37. 
   
  
  
  
  37.  
    38. 
   
  
  
  
  38.         public IPresenter Presenter  
    39. 
   
  
  
  
  39.         {  
    40. 
   
  
  
  
  40.             get 
    41. 
   
  
  
  
  41.             {  
    42. 
   
  
  
  
  42.                 return _presenter;  
    43. 
   
  
  
  
  43.             }  
    44. 
   
  
  
  
  44.             set 
    45. 
   
  
  
  
  45.             {  
    46. 
   
  
  
  
  46.                 _presenter = value;  
    47. 
   
  
  
  
  47.             }  
    48. 
   
  
  
  
  48.         }  
    49. 
   
  
  
  
  49.  
    50. 
   
  
  
  
  50.         public void ShowResult(string result)  
    51. 
   
  
  
  
  51.         {  
    52. 
   
  
  
  
  52.             MessageBox.Show(result);  
    53. 
   
  
  
  
  53.         }  
    54. 
   
  
  
  
  54.  
    55. 
   
  
  
  
  55.         public int ValueOne  
    56. 
   
  
  
  
  56.         {  
    57. 
   
  
  
  
  57.             get { return int.Parse(tb1.Text); }  
    58. 
   
  
  
  
  58.         }  
    59. 
   
  
  
  
  59.  
    60. 
   
  
  
  
  60.         public int ValueTwo  
    61. 
   
  
  
  
  61.         {  
    62. 
   
  
  
  
  62.             get { return int.Parse(tb2.Text); }  
    63. 
   
  
  
  
  63.         }  
    64. 
   
  
  
  
  64.     }  
    65. 
   
  
  
  
  65. } 
    66.

一个很简单的东西，看上去写成的要多些那么一坨东西，但是好处是显而易见的，就是更换view非常方便，根本不用去改你的IPresenter、Presenter和业务。一切都是接口调用而不依赖具体实现，这就是好处。

你必须要懂的MVVM

对于.NET平台的开发人员，托微软的福分我们拥有一种更为强大的模型---MVVM。这应该算是做WPF/Silverlight应用的人必懂的一种结构，WPF/silverlight天生支持数据绑定和命令绑定（不过sl在命令绑定上还比较弱），这就为我们使用MVVM创造了可能。

View是什么呢，纯的View只有xaml或者附带必要的只与View本身相关逻辑代码。ViewModel，你可以把它理解为View具体呈现内容所依赖数据的一个抽象，在MVVM中View与ViewModel总会有一种绑定关系，一旦ViewModel中被绑定的数据发生改变View上的数据就会跟着变，相反也有可能，比如你的账号密码框内容发生变化，关联的ViewModel中的数据就会被框架自动通知到。

在wpf/silverlight中，绑定是通过xaml语法来完成（虽然你可以选择用c#来写但不符合mvvm的宗旨），并且绑定双方的通知机制是有框架来完成，也就是说一个会xaml和blend的美工只需事先和coder商量下“咱们的xx和xx是在哪个ViewModel上叫XXX的属性的XXX属性……”问题之后就可以各干各的了。那么ViewModel怎么写，咋view中又怎么绑定到viewmodel呢？首先我们谈ViewModel。

说道ViewModel你需要知道依赖属性和依赖对象的概念，这是wpf/silverlight的基础所以不多说。有两种方式写ViewModel。***种是自己去实现INotifyPropertyChanged接口，并在属性变化时去调用NotifyPropertyChanged事件。

为了方便我们定义一个ViewModelBase的抽象基类，然后让其他ViewModel继承这个基类。

ViewModelBase

 
 
 
 
    
  
  
  
  
  1. public abstract class ViewModelBase : System.ComponentModel.INotifyPropertyChanged, IDisposable   
    2. 
  
  
  
  
  2.     {   
    3. 
  
  
  
  
  3.         public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;   
    4. 
  
  
  
  
  4.         protected void OnPropertyChanged(string propertyName)   
    5. 
  
  
  
  
  5.         {   
    6. 
  
  
  
  
  6.             if (PropertyChanged != null)   
    7. 
  
  
  
  
  7.             {   
    8. 
  
  
  
  
  8.       var arg = new System.ComponentModel.PropertyChangedEventArgs(propertyName);   
    9. 
  
  
  
  
  9.                 PropertyChanged(this, arg);   
    10. 
  
  
  
  
  10.             }   
    11. 
  
  
  
  
  11.         }   
    12. 
  
  
  
  
  12.         public virtual void Dispose()   
    13. 
  
  
  
  
  13.         {   
    14. 
  
  
  
  
  14.              
    15. 
  
  
  
  
  15.         }   
    16. 
  
  
  
  
  16.     } 
    17.

 

 
 
 
 
    
  
  
  
  
  1. DemoViewModel public class DemoViewModel : ViewModelBase     
    2. 
  
  
  
  
  2.  {          
    3. 
  
  
  
  
  3. #region fields          
    4. 
  
  
  
  
  4. private string _propertyA;          
    5. 
  
  
  
  
  5. #endregion          
    6. 
  
  
  
  
  6. #region presentation properties          
    7. 
  
  
  
  
  7. public string PropertyA          
    8. 
  
  
  
  
  8. {              
    9. 
  
  
  
  
  9. get              
    10. 
  
  
  
  
  10. {                 
    11. 
  
  
  
  
  11.  return _propertyA;           
    12. 
  
  
  
  
  12.    }              
    13. 
  
  
  
  
  13. set        
    14. 
  
  
  
  
  14.       {                  
    15. 
  
  
  
  
  15. if (_propertyA != value)                
    16. 
  
  
  
  
  16. {                      
    17. 
  
  
  
  
  17. _propertyA = value;                   
    18. 
  
  
  
  
  18. base.OnPropertyChanged("PropertyA");             
    19. 
  
  
  
  
  19.      }         
    20. 
  
  
  
  
  20.      }        }        
    21. 
  
  
  
  
  21.   #endregion    } 
    22.

第二种是利用DependencyObject和DependencyProperty。

PeopleItemViewModel

 
 
 
 
    
  
  
  
  
  1. public class PeopleItemViewModel : DependencyObject, IPeopleItemViewModel  
    2. 
  
  
  
  
  2.     {  
    3. 
  
  
  
  
  3.         public PeopleItemViewModel()  
    4. 
  
  
  
  
  4.         {  
    5. 
  
  
  
  
  5.               
    6. 
  
  
  
  
  6.         }  
    7. 
  
  
  
  
  7. public static readonly DependencyProperty SimpleUserDataProperty = DependencyProperty.Register("SimpleUserData", typeof(SimpleUserData), typeof(PeopleItemViewModel));  
    8. 
  
  
  
  
  8. public static readonly DependencyProperty RelativeSimpleUserDataProperty = DependencyProperty.Register("RelativeSimpleUserData", typeof(ObservableCollection), typeof(PeopleItemViewModel));  
    9. 
  
  
  
  
  9. public static readonly DependencyProperty AllSimpleUserDataProperty = DependencyProperty.Register("AllSimpleUserData", typeof(ObservableCollection), typeof(PeopleItemViewModel));  
    10. 
  
  
  
  
  10.  
    11. 
  
  
  
  
  11.         public SimpleUserData SimpleUserData  
    12. 
  
  
  
  
  12.         {  
    13. 
  
  
  
  
  13.             get 
    14. 
  
  
  
  
  14.             {  
    15. 
  
  
  
  
  15.                 return (SimpleUserData)base.GetValue(SimpleUserDataProperty);  
    16. 
  
  
  
  
  16.             }  
    17. 
  
  
  
  
  17.             set 
    18. 
  
  
  
  
  18.             {  
    19. 
  
  
  
  
  19.                 if (!base.CheckAccess())  
    20. 
  
  
  
  
  20.                 {  
    21. 
  
  
  
  
  21.                     Dispatcher.Invoke(new Action(  
    22. 
  
  
  
  
  22.                         () =>  
    23. 
  
  
  
  
  23.                         {  
    24. 
  
  
  
  
  24.                             SimpleUserData = value;  
    25. 
  
  
  
  
  25.                         }));  
    26. 
  
  
  
  
  26.                 }  
    27. 
  
  
  
  
  27.                 else 
    28. 
  
  
  
  
  28.                     base.SetValue(SimpleUserDataProperty, value);  
    29. 
  
  
  
  
  29.             }  
    30. 
  
  
  
  
  30.         }  
    31. 
  
  
  
  
  31.         public ObservableCollection RelativeSimpleUserData  
    32. 
  
  
  
  
  32.         {  
    33. 
  
  
  
  
  33.             get 
    34. 
  
  
  
  
  34.             {  
    35. 
  
  
  
  
  35. return (ObservableCollection)base.GetValue(RelativeSimpleUserDataProperty);  
    36. 
  
  
  
  
  36.             }  
    37. 
  
  
  
  
  37.             set 
    38. 
  
  
  
  
  38.             {  
    39. 
  
  
  
  
  39.                 if (!base.CheckAccess())  
    40. 
  
  
  
  
  40.                 {  
    41. 
  
  
  
  
  41.                     Dispatcher.Invoke(new Action(  
    42. 
  
  
  
  
  42.                         () =>  
    43. 
  
  
  
  
  43.                         {  
    44. 
  
  
  
  
  44.                             RelativeSimpleUserData = value;  
    45. 
  
  
  
  
  45.                         }));  
    46. 
  
  
  
  
  46.                 }  
    47. 
  
  
  
  
  47.                 else 
    48. 
  
  
  
  
  48.                 {  
    49. 
  
  
  
  
  49. base.SetValue(RelativeSimpleUserDataProperty, value);  
    50. 
  
  
  
  
  50. var collectionView = CollectionViewSource.GetDefaultView(value);  
    51. 
  
  
  
  
  51. collectionView.SortDescriptions.Add(new SortDescription("Distance", ListSortDirection.Ascending));  
    52. 
  
  
  
  
  52.                 }  
    53. 
  
  
  
  
  53.             }  
    54. 
  
  
  
  
  54.         }  
    55. 
  
  
  
  
  55.         public ObservableCollection AllSimpleUserData  
    56. 
  
  
  
  
  56.         {  
    57. 
  
  
  
  
  57.             get 
    58. 
  
  
  
  
  58.             {  
    59. 
  
  
  
  
  59.       return (ObservableCollection)base.GetValue(AllSimpleUserDataProperty);  
    60. 
  
  
  
  
  60.             }  
    61. 
  
  
  
  
  61.             set 
    62. 
  
  
  
  
  62.             {  
    63. 
  
  
  
  
  63.                 if (!base.CheckAccess())  
    64. 
  
  
  
  
  64.                 {  
    65. 
  
  
  
  
  65.                     Dispatcher.Invoke(new Action(  
    66. 
  
  
  
  
  66.                         () =>  
    67. 
  
  
  
  
  67.                         {  
    68. 
  
  
  
  
  68.                             AllSimpleUserData = value;  
    69. 
  
  
  
  
  69.                         }));  
    70. 
  
  
  
  
  70.                 }  
    71. 
  
  
  
  
  71.                 else 
    72. 
  
  
  
  
  72.                 {  
    73. 
  
  
  
  
  73. base.SetValue(AllSimpleUserDataProperty, value);  
    74. 
  
  
  
  
  74. var collectionView = CollectionViewSource.GetDefaultView(value);  
    75. 
  
  
  
  
  75. collectionView.SortDescriptions.Add(new SortDescription("Distance", ListSortDirection.Ascending));  
    76. 
  
  
  
  
  76.                 }  
    77. 
  
  
  
  
  77.             }  
    78. 
  
  
  
  
  78.         }  
    79. 
  
  
  
  
  79. } 
    80.

在View中绑定ViewModel。

为了方便，我们可以在app.xaml中将需要的viewmode放到全局资源字典中。

然后再我们的vs视图设计器Properties(中文版显示的是“属性”)页上选择为绑定源设置绑定目标（包括source和path等）以及必要的值转换器等等即可。

（PS:虽然vs很强大，但个人还是建议熟悉xaml的绑定语法，想当初用vs2008搞wpf的时候貌似还没有这么方便的设计器。）

本文名称：.NET程序员应该熟悉的开发模式
网页网址：http://www.gawzjz.com/qtweb/news0/193500.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

网站策划知识

行业网站建设

成都网站维护　　 　成都微信小程序开发　　 　川西大数据中心　　 　汕尾凯敏网站　　 　铁科精智测控　　 　江油做网站　　 　成都学生服定制　　 　重庆服务器托管　　 　手机APP开发　　 　造型师设计　　 　成都未宇聚　　 　品牌网站建设　　 　盐亭网站建设　　 　马边网站建设　　 　手机网站建设套餐　　 　免备案虚拟主机　　 　响应式网站　　 　手机app　　 　成都托管服务器　　 　内江做网站