首页 文章 精选 留言 我的

.NET多层架构告别大学青春

2017-11-15 514

   相隔上次的asp.net三层架构解析，不知道大家有木有去试试，做出一两个自己的功能模块，其实都很简单，只是在摸索的路上有些难而已。加油啊！未来不等人。j_0028.gif

   接着上次的教程继续说，还在学校的时候真的见识太少，对于现在公司的要求都是可望不可即，也就见怪不怪应届生的竞争力是多么不值得一提了，所以提前给自己找个好公司，去帮公司解决问题，才是学习和进步的正确方向，学校的生活只是一个儿时的梦想实现的倒影，不要过于迷恋了。

   好了，又说教了，话说自己马上大四毕业，对于一些小学弟总是想多唠叨几句，嘿嘿j_0010.gif为了你们好，要知道，社会不会袒护和关心任何人。学的东西都是自己的，下面来看看多层架构的企业网站级别是什么样子的。

   这里由于版权之类的问题，我就不截图了，直接给大家看看做的代码截图，如图，


155914534.jpg

  可以看到这才是社会需要的标准，我们还是太年轻了，因为这些东西还只是最基本的，不过给大家展示的这个企业后台客户关系管理系统的权限业务逻辑算是郑州的最高水准了，不信的可以慢慢看下面的演示，耐心。。

   这个后台的复杂程度是和北京Lenovo研发部门持平的，PS：因为就是从那里传出来的，架构师说的。j_0016.gif我用了大概九天才学会了这个系统的权限管理，因为里面可以控制权限到每个页面的标签，写的非常强大。

   开始的接触的时候我是从PD入手的，看到了传说中的云图，公司规定这个不能带出，所以就没法给图了，不过这个图大概有30多个表，我也记不了啊。。不过为了给大家演示效果，我凭着印象大概记下了一些关键的业务逻辑构思的方法，试了画了一个，大家可以从图中清楚的分析出来这块的权限管理方法，如下图，PS：不知道这算不算给公司泄密。。我想应该不会有公司的人看的博客吧，我人气很低的。。看不到看不到。。毕竟公司这么框架，这个九牛一毛啊。好东西就是要分享学习嘛。j_0012.gif


160818317.jpg


  这样就熟悉了权限管理的业务逻辑实现方法，接下来就是对于使用什么样的架构来写这么庞大的一个系统，选择三层显然已经满足不了，所以就开始学习了传说中的多层架构 - 工厂模式来开发这个后台。一般的小公司会选择用动软来构架好一些基本的类库和方法，这样来一步步的修改功能，不过大公司的会考虑效率问题，最后我所在的公司介绍了一种代码生成器SocanCode，用这个的好处是可以定制属于自己的代码类库，非常巧妙的使用JS编写了一套替换代码的生成方法，大家可以试SocanCode，如图，PS：右侧的模版就是修改定制自己想要的代码规范，这里就不详述了，因为网上的教程很多，下面来介绍生成后的类库使用方法。

162022348.jpg


这样生成了我们要写的业务，三层架构的模版文件，如图，

162508758.jpg


然后把各种页面的四操作写出来，对于大家来说应该不难吧，我在上期写过一个例子，这里就不多说了。写好后就添加类库到本项目中，如图，

164842157.jpg

164842182.jpg

164842302.jpg


    这样订制的代码有很高的质量，但是没什么成就感。j_0008.gif给大家一个四操作的例子吧，省得有人说我不给demo，


TVisitBLL:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
using  System;
using  System.Collections.Generic;
using  System.Text.RegularExpressions;
using  System.Web;
using  System.Web.Caching;
namespace  BLL
{
     /// <summary>
     /// 业务逻辑类 TVisitBLL
     /// </summary>
     public  class  TVisitBLL: BLHelper
     {
         private  readonly  DAL.TVisitDAL dal =  new  DAL.TVisitDAL();
         public  TVisitBLL()
             :  base ( "_TVisit_" ) { }
         /// <summary>
         /// 增加一条数据
         /// </summary>
         public  void  Add(Model.TVisitModel model)
         {
             dal.Add(model);
         }
         /// <summary>
         /// 更新一条数据
         /// </summary>
         public  void  Update(Model.TVisitModel model)
         {
             int  count = dal.Update(model);
             if  (EnableCache && count > 0)
             {
                 RemoveModelCache(model.VisitId);
             }
         }
         /// <summary>
         /// 删除一条数据
         /// </summary>
         public  void  Delete( int ? VisitId)
         {
             int  count = dal.Delete(VisitId);
             if  (EnableCache && count > 0)
             {
                 RemoveModelCache(VisitId.ToString());
             }
         }
         /// <summary>
         /// 是否存在该记录
         /// </summary>
         public  bool  Exists( int ? VisitId)
         {
             bool  bln = dal.Exists(VisitId);
             return  bln;
         }
         /// <summary>
         /// 得到一个对象实体
         /// </summary>
         public  Model.TVisitModel GetModel( int ? VisitId)
         {
             Model.TVisitModel model =  null ;
             if  (!EnableCache)
             {
                 model = dal.GetModel(VisitId);
             }
             else
             {
                 string  key = VisitId.ToString();
                 if  (GetModelCache(key) !=  null )
                 {
                     model = (Model.TVisitModel)GetModelCache(key);
                 }
                 else
                 {
                     model = dal.GetModel(VisitId);
                     TryAddModelCache(key, model,  null , Cache.NoAbsoluteExpiration, Cache.NoSlidingExpiration, System.Web.Caching.CacheItemPriority.Normal,  null );
                 }
             }
             return  model;
         }
         /// <summary>
         /// 获得泛型数据列表
         /// </summary>
         public  List<Model.TVisitModel> GetList()
         {
             List<Model.TVisitModel> lst = dal.GetList();
             return  lst;
         }
         /// <summary>
         /// 分页获取泛型数据列表
         /// </summary>
         public  PageList<Model.TVisitModel> GetPageList(PageInfo pi)
         {
             PageList<Model.TVisitModel> pl = dal.GetPageList(pi);
             return  pl;
         }
     }
}


TVisitDAL:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
using  System;
using  System.Collections.Generic;
using  System.Data;
using  System.Data.Common;
using  System.Text;
namespace  DAL
{
     /// <summary>
     /// 数据访问类 TVisitDAL
     /// <summary>
     public  partial  class  TVisitDAL : DALHelper
     {
         /// <summary>
         /// 增加一条数据
         /// </summary>
         public  int  Add(Model.TVisitModel model)
         {
             IDbDataParameter[] parms4TVisit = PrepareAddParameters(model);
             return  dbHelper.ExecuteNonQuery(CommandType.StoredProcedure, COMMAND_ADD, parms4TVisit);
         }
         /// <summary>
         /// 更新一条数据
         /// </summary>
         public  int  Update(Model.TVisitModel model)
         {
             IDbDataParameter[] parms4TVisit = PrepareUpdateParameters(model);
             return  dbHelper.ExecuteNonQuery(CommandType.StoredProcedure, COMMAND_UPDATE, parms4TVisit);
         }
         /// <summary>
         /// 删除一条数据
         /// </summary>
         public  int  Delete( int ? VisitId)
         {
             IDbDataParameter[] parms4TVisit = PrepareDeleteParameters(VisitId);
             return  dbHelper.ExecuteNonQuery(CommandType.StoredProcedure, COMMAND_DELETE, parms4TVisit);
         }
         /// <summary>
         /// 得到一个对象实体
         /// </summary>
         public  Model.TVisitModel GetModel( int ? VisitId)
         {
             IDbDataParameter[] parms4TVisit = PrepareGetModelParameters(VisitId);
             using  (IDataReader dr = dbHelper.ExecuteReader(CommandType.StoredProcedure, COMMAND_GETMODEL, parms4TVisit))
             {
                 if  (dr.Read())  return  GetModel(dr);
                 return  null ;
             }
         }
         /// <summary>
         /// 是否存在该记录
         /// </summary>
         public  bool  Exists( int ? VisitId)
         {
             IDbDataParameter[] parms4TVisit = PrepareExistParameters(VisitId);
             object  obj = dbHelper.ExecuteScalar(CommandType.StoredProcedure, COMMAND_EXISTS, parms4TVisit);
             return  int .Parse(obj.ToString()) > 0;
         }
         /// <summary>
         /// 获取数量
         /// </summary>
         public  int  GetCount()
         {
             object  obj = dbHelper.ExecuteScalar(CommandType.StoredProcedure, COMMAND_GETCOUNT,  null );
             return  int .Parse(obj.ToString());
         }
         /// <summary>
         /// 获取泛型数据列表
         /// </summary>
         public  List<Model.TVisitModel> GetList()
         {
             using  (IDataReader dr = dbHelper.ExecuteReader(CommandType.StoredProcedure, COMMAND_GETLIST,  null ))
             {
                 List<Model.TVisitModel> lst =  new  List<Model.TVisitModel>();
                 ExecuteReaderAction(dr, r => lst.Add(GetModel(r)));
                 return  lst;
             }
         }
         /// <summary>
         /// 分页获取泛型数据列表
         /// </summary>
         public  PageList<Model.TVisitModel> GetPageList(PageInfo pi)
         {
             pi.RecordCount = GetCount();
             pi.Compute();
             PageList<Model.TVisitModel> pl =  new  PageList<Model.TVisitModel>(pi);
             using  (IDataReader dr = dbHelper.ExecuteReader(CommandType.Text, COMMAND_GETLIST,  null ))
             {
                 pl.List =  new  List<Model.TVisitModel>();
                 ExecuteReaderAction(dr, pi.FirstIndex, pi.PageSize, r => pl.List.Add(GetModel(r)));
             }
             return  pl;
         }
         /// <summary>
         /// 由一行数据得到一个实体
         /// </summary>
         private  Model.TVisitModel GetModel(IDataReader dr)
         {
             Model.TVisitModel model =  new  Model.TVisitModel();
             PrepareModel(model, dr);
             return  model;
         }
     }
}




TVisitDAL:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
using  System;
using  System.Collections.Generic;
using  System.Data;
using  System.Data.Common;
using  System.Text;
using  DBUtility;
namespace  DAL
{
     /// <summary>
     /// 数据访问类 TVisit ，此类请勿动，以方便表字段更改时重新生成覆盖
     /// </summary>
     public  partial  class  TVisitDAL
     {
         internal  const  string  COMMAND_ADD =  "sp_TVisit_Add" ;
         internal  const  string  COMMAND_UPDATE =  "sp_TVisit_Update" ;
         internal  const  string  COMMAND_DELETE =  "sp_TVisit_Delete" ;
         internal  const  string  COMMAND_EXISTS =  "sp_TVisit_Exists" ;
         internal  const  string  COMMAND_GETMODEL =  "sp_TVisit_GetModel" ;
         internal  const  string  COMMAND_GETCOUNT =  "sp_TVisit_GetCount" ;
         internal  const  string  COMMAND_GETLIST =  "sp_TVisit_GetAllList" ;
         internal  const  string  PARM_VISITID =  "@in_VisitId" ;
         internal  const  string  PARM_VISITTIME =  "@in_VisitTime" ;
         internal  const  string  PARM_VISITCUSTOMER =  "@in_VisitCustomer" ;
         internal  const  string  PARM_VISITWAY =  "@in_VisitWay" ;
         internal  const  string  PARM_VISITCONTENT =  "@in_VisitContent" ;
         internal  const  string  PARM_VISITOR =  "@in_Visitor" ;
         internal  const  string  PARM_FREMARK =  "@in_FRemark" ;
         internal  const  string  PARM_FSORT =  "@in_FSort" ;
         internal  const  string  PARM_FISDELETE =  "@in_FIsDelete" ;
         internal  const  string  PARM_FCREATOR =  "@in_FCreator" ;
         internal  const  string  PARM_FCREATEDATE =  "@in_FCreateDate" ;
         internal  const  string  PARM_FMODIFY =  "@in_FModify" ;
         internal  const  string  PARM_FMODIFYDATE =  "@in_FModifyDate" ;
         internal  const  string  PARM_FGUID =  "@in_FGUID" ;
         internal  const  string  PARM_FISSYNCHRONOUS =  "@in_FIsSynchronous" ;
         /// <summary>
         /// 为新增一条数据准备参数
         /// </summary>
         internal  static  IDbDataParameter[] PrepareAddParameters(Model.TVisitModel model)
         {
             IDbDataParameter[] parms = DbParameterCache.GetCachedParameterSet(dbHelper.ConnectionString, COMMAND_ADD);
             if  (parms ==  null )
             {
                 parms =  new  IDbDataParameter[]{
                     dbHelper.CreateDbParameter(PARM_VISITTIME, DbType.DateTime, ParameterDirection.Input),
                     dbHelper.CreateDbParameter(PARM_VISITCUSTOMER, DbType.Int32, ParameterDirection.Input),
                     dbHelper.CreateDbParameter(PARM_VISITWAY, DbType.Int32, ParameterDirection.Input),
                     dbHelper.CreateDbParameter(PARM_VISITCONTENT, DbType.AnsiString, ParameterDirection.Input),
                     dbHelper.CreateDbParameter(PARM_VISITOR, DbType.Int32, ParameterDirection.Input),
                     dbHelper.CreateDbParameter(PARM_FREMARK, DbType.String, ParameterDirection.Input),
                     dbHelper.CreateDbParameter(PARM_FSORT, DbType.Int32, ParameterDirection.Input),
                     dbHelper.CreateDbParameter(PARM_FISDELETE, DbType.Boolean, ParameterDirection.Input),
                     dbHelper.CreateDbParameter(PARM_FCREATOR, DbType.AnsiString, ParameterDirection.Input),
                     dbHelper.CreateDbParameter(PARM_FCREATEDATE, DbType.DateTime, ParameterDirection.Input),
                     dbHelper.CreateDbParameter(PARM_FMODIFY, DbType.AnsiString, ParameterDirection.Input),
                     dbHelper.CreateDbParameter(PARM_FMODIFYDATE, DbType.DateTime, ParameterDirection.Input),
                     dbHelper.CreateDbParameter(PARM_FGUID, DbType.AnsiString, ParameterDirection.Input),
                     dbHelper.CreateDbParameter(PARM_FISSYNCHRONOUS, DbType.Boolean, ParameterDirection.Input)};
                 DbParameterCache.CacheParameterSet(dbHelper.ConnectionString, COMMAND_ADD, parms);
             }
             parms[0].Value = model.VisitTime;
             parms[1].Value = model.VisitCustomer;
             parms[2].Value = model.VisitWay;
             parms[3].Value = model.VisitContent;
             parms[4].Value = model.Visitor;
             parms[5].Value = model.FRemark;
             parms[6].Value = model.FSort;
             parms[7].Value = model.FIsDelete;
             parms[8].Value = model.FCreator;
             parms[9].Value = model.FCreateDate;
             parms[10].Value = model.FModify;
             parms[11].Value = model.FModifyDate;
             parms[12].Value = model.FGUID;
             parms[13].Value = model.FIsSynchronous;
             return  parms;
         }
         /// <summary>
         /// 为更新一条数据准备参数
         /// </summary>
         internal  static  IDbDataParameter[] PrepareUpdateParameters(Model.TVisitModel model)
         {
             IDbDataParameter[] parms = DbParameterCache.GetCachedParameterSet(dbHelper.ConnectionString, COMMAND_UPDATE);
             if  (parms ==  null )
             {
                 parms =  new  IDbDataParameter[]{
                     dbHelper.CreateDbParameter(PARM_VISITTIME, DbType.DateTime, ParameterDirection.Input),
                     dbHelper.CreateDbParameter(PARM_VISITCUSTOMER, DbType.Int32, ParameterDirection.Input),
                     dbHelper.CreateDbParameter(PARM_VISITWAY, DbType.Int32, ParameterDirection.Input),
                     dbHelper.CreateDbParameter(PARM_VISITCONTENT, DbType.AnsiString, ParameterDirection.Input),
                     dbHelper.CreateDbParameter(PARM_VISITOR, DbType.Int32, ParameterDirection.Input),
                     dbHelper.CreateDbParameter(PARM_FREMARK, DbType.String, ParameterDirection.Input),
                     dbHelper.CreateDbParameter(PARM_FSORT, DbType.Int32, ParameterDirection.Input),
                     dbHelper.CreateDbParameter(PARM_FISDELETE, DbType.Boolean, ParameterDirection.Input),
                     dbHelper.CreateDbParameter(PARM_FCREATOR, DbType.AnsiString, ParameterDirection.Input),
                     dbHelper.CreateDbParameter(PARM_FCREATEDATE, DbType.DateTime, ParameterDirection.Input),
                     dbHelper.CreateDbParameter(PARM_FMODIFY, DbType.AnsiString, ParameterDirection.Input),
                     dbHelper.CreateDbParameter(PARM_FMODIFYDATE, DbType.DateTime, ParameterDirection.Input),
                     dbHelper.CreateDbParameter(PARM_FGUID, DbType.AnsiString, ParameterDirection.Input),
                     dbHelper.CreateDbParameter(PARM_FISSYNCHRONOUS, DbType.Boolean, ParameterDirection.Input),
                     dbHelper.CreateDbParameter(PARM_VISITID, DbType.Int32, ParameterDirection.Input)};
                 DbParameterCache.CacheParameterSet(dbHelper.ConnectionString, COMMAND_UPDATE, parms);
             }
             parms[0].Value = model.VisitTime;
             parms[1].Value = model.VisitCustomer;
             parms[2].Value = model.VisitWay;
             parms[3].Value = model.VisitContent;
             parms[4].Value = model.Visitor;
             parms[5].Value = model.FRemark;
             parms[6].Value = model.FSort;
             parms[7].Value = model.FIsDelete;
             parms[8].Value = model.FCreator;
             parms[9].Value = model.FCreateDate;
             parms[10].Value = model.FModify;
             parms[11].Value = model.FModifyDate;
             parms[12].Value = model.FGUID;
             parms[13].Value = model.FIsSynchronous;
             parms[14].Value = model.VisitId;
             return  parms;
         }
         /// <summary>
         /// 为删除一条数据准备参数
         /// </summary>
         internal  static  IDbDataParameter[] PrepareDeleteParameters( int ? VisitId)
         {
             IDbDataParameter[] parms = DbParameterCache.GetCachedParameterSet(dbHelper.ConnectionString, COMMAND_DELETE);
             if  (parms ==  null )
             {
                 parms =  new  IDbDataParameter[]{
                     dbHelper.CreateDbParameter(PARM_VISITID, DbType.Int32, ParameterDirection.Input)};
                 DbParameterCache.CacheParameterSet(dbHelper.ConnectionString, COMMAND_EXISTS, parms);
             }
             parms[0].Value = VisitId;
             return  parms;
         }
         /// <summary>
         /// 为查询是否存在一条数据准备参数
         /// </summary>
         internal  static  IDbDataParameter[] PrepareExistParameters( int ? VisitId)
         {
             IDbDataParameter[] parms = DbParameterCache.GetCachedParameterSet(dbHelper.ConnectionString, COMMAND_EXISTS);
             if  (parms ==  null )
             {
                 parms =  new  IDbDataParameter[]{
                     dbHelper.CreateDbParameter(PARM_VISITID, DbType.Int32, ParameterDirection.Input)};
                 DbParameterCache.CacheParameterSet(dbHelper.ConnectionString, COMMAND_EXISTS, parms);
             }
             parms[0].Value = VisitId;
             return  parms;
         }
         /// <summary>
         /// 为获取一条数据准备参数
         /// </summary>
         internal  static  IDbDataParameter[] PrepareGetModelParameters( int ? VisitId)
         {
             IDbDataParameter[] parms = DbParameterCache.GetCachedParameterSet(dbHelper.ConnectionString, COMMAND_GETMODEL);
             if  (parms ==  null )
             {
                 parms =  new  IDbDataParameter[]{
                     dbHelper.CreateDbParameter(PARM_VISITID, DbType.Int32, ParameterDirection.Input)};
                 DbParameterCache.CacheParameterSet(dbHelper.ConnectionString, COMMAND_EXISTS, parms);
             }
             parms[0].Value = VisitId;
             return  parms;
         }
         /// <summary>
         /// 由一行数据得到一个实体
         /// </summary>
         internal  static  void  PrepareModel(Model.TVisitModel model, IDataReader dr)
         {
             model.VisitId = DbValue.GetInt(dr[ "VisitId" ]);
             model.VisitTime = DbValue.GetDateTime(dr[ "VisitTime" ]);
             model.VisitCustomer = DbValue.GetInt(dr[ "VisitCustomer" ]);
             model.VisitWay = DbValue.GetInt(dr[ "VisitWay" ]);
             model.VisitContent = DbValue.GetString(dr[ "VisitContent" ]);
             model.Visitor = DbValue.GetInt(dr[ "Visitor" ]);
             model.FRemark = DbValue.GetString(dr[ "FRemark" ]);
             model.FSort = DbValue.GetInt(dr[ "FSort" ]);
             model.FIsDelete = DbValue.GetBool(dr[ "FIsDelete" ]);
             model.FCreator = DbValue.GetString(dr[ "FCreator" ]);
             model.FCreateDate = DbValue.GetDateTime(dr[ "FCreateDate" ]);
             model.FModify = DbValue.GetString(dr[ "FModify" ]);
             model.FModifyDate = DbValue.GetDateTime(dr[ "FModifyDate" ]);
             model.FGUID = DbValue.GetString(dr[ "FGUID" ]);
             model.FIsSynchronous = DbValue.GetBool(dr[ "FIsSynchronous" ]);
         }
     }
}



TVisitModel:

1
2
3
4
5
6
7
8
9
10
using  System;
using  System.Collections.Generic;
namespace  Model
{
     /// <summary>
     /// 实体类 TVisitModel
     /// </summary>
     public  partial  class  TVisitModel
     { }
}


TVisitModel:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
using  System;
namespace  Model
{
     /// <summary>
     /// 实体类 TVisitModel, 此类请勿动，以方便表字段更改时重新生成覆盖
     /// </summary>
     [Serializable]
     public  partial  class  TVisitModel : ICloneable
     {
         public  TVisitModel()
         { }
         /// <summary>
         /// 构造函数 TVisitModel
         /// </summary>
         /// <param name="visitid">拜访编号</param>
         /// <param name="visittime">拜访时间</param>
         /// <param name="visitcustomer">拜访对象编号</param>
         /// <param name="visitway">拜访方式</param>
         /// <param name="visitcontent">拜访内容</param>
         /// <param name="visitor">拜访人员</param>
         /// <param name="fremark">备注</param>
         /// <param name="fsort">显示顺序</param>
         /// <param name="fisdelete">是否被删除：默认0</param>
         /// <param name="fcreator">创建者</param>
         /// <param name="fcreatedate">创建日期</param>
         /// <param name="fmodify">修改者</param>
         /// <param name="fmodifydate">修改日期</param>
         /// <param name="fguid">唯一标识</param>
         /// <param name="fissynchronous">是否已同步</param>
         public  TVisitModel( int ? visitid, DateTime? visittime,  int ? visitcustomer,  int ? visitway,  string  visitcontent,  int ? visitor,  string  fremark,  int ? fsort,  bool ? fisdelete,  string  fcreator, DateTime? fcreatedate,  string  fmodify, DateTime? fmodifydate,  string  fguid,  bool ? fissynchronous)
         {
             this .VisitId = visitid;
             this .VisitTime = visittime;
             this .VisitCustomer = visitcustomer;
             this .VisitWay = visitway;
             this .VisitContent = visitcontent;
             this .Visitor = visitor;
             this .FRemark = fremark;
             this .FSort = fsort;
             this .FIsDelete = fisdelete;
             this .FCreator = fcreator;
             this .FCreateDate = fcreatedate;
             this .FModify = fmodify;
             this .FModifyDate = fmodifydate;
             this .FGUID = fguid;
             this .FIsSynchronous = fissynchronous;
         }
         #region 实体属性
         /// <summary>
         /// 拜访编号
         /// </summary>
         public  int ? VisitId {  get ;  set ; }
         /// <summary>
         /// 拜访时间
         /// </summary>
         public  DateTime? VisitTime {  get ;  set ; }
         /// <summary>
         /// 拜访对象编号
         /// </summary>
         public  int ? VisitCustomer {  get ;  set ; }
         /// <summary>
         /// 拜访方式
         /// </summary>
         public  int ? VisitWay {  get ;  set ; }
         /// <summary>
         /// 拜访内容
         /// </summary>
         public  string  VisitContent {  get ;  set ; }
         /// <summary>
         /// 拜访人员
         /// </summary>
         public  int ? Visitor {  get ;  set ; }
         /// <summary>
         /// 备注
         /// </summary>
         public  string  FRemark {  get ;  set ; }
         /// <summary>
         /// 显示顺序
         /// </summary>
         public  int ? FSort {  get ;  set ; }
         /// <summary>
         /// 是否被删除：默认0
         /// </summary>
         public  bool ? FIsDelete {  get ;  set ; }
         /// <summary>
         /// 创建者
         /// </summary>
         public  string  FCreator {  get ;  set ; }
         /// <summary>
         /// 创建日期
         /// </summary>
         public  DateTime? FCreateDate {  get ;  set ; }
         /// <summary>
         /// 修改者
         /// </summary>
         public  string  FModify {  get ;  set ; }
         /// <summary>
         /// 修改日期
         /// </summary>
         public  DateTime? FModifyDate {  get ;  set ; }
         /// <summary>
         /// 唯一标识
         /// </summary>
         public  string  FGUID {  get ;  set ; }
         /// <summary>
         /// 是否已同步
         /// </summary>
         public  bool ? FIsSynchronous {  get ;  set ; }
         #endregion
         #region ICloneable 成员
         public  object  Clone()
         {
             return  this .MemberwiseClone();
         }
         #endregion
         public  override  bool  Equals( object  obj)
         {
             Model.TVisitModel model = obj  as  Model.TVisitModel;
             if  (model !=  null  && model.VisitId ==  this .VisitId)
                 return  true ;
             return  false ;
         }
         public  override  int  GetHashCode()
         {
             return  VisitId.GetHashCode();
         }
     }
}


   总算写完了这个业务的功能模块代码，呃。。。累死了，继续说，下面就可以基于其他的模块进行系统的四操作开发了，比如，在web里面写自己的页面，提示：这里大家可以定义一个topmasterSite1.Master放置自己的title功能显示，这样就避免了很多繁杂的多余模块的产生，PS：这个是架构师教我的，嘿嘿。。。j_0010.gif

   好了到这里就给大家简单的介绍完了多层架构的基本使用方法了，工厂的核心在于接口的调用，其实也就多了接口的实例化引用对象，可以方便的调用到各种XXOODAL，所以大家如果想用好多层就要学会接口的方法使用。大部分的网站都可以用三层解决的话，是不建议用工厂的，所以掌握住基本的才是王道。

  这次的东西有点多，大家慢慢理解，我会再用一期的时间把这个项目简单的介绍完，让大家知道其中的一些核心写法，具体的细节需要大家自己去写代码去修改和优化。









本文转自 吴雨声 51CTO博客，原文链接：http://blog.51cto.com/liangxiao/1281748，如需转载请自行联系原作者
上一篇 下一篇
优秀的个人博客,低调大师

微信关注我们

原文链接：https://yq.aliyun.com/articles/465087

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

Owin中间件动手做

摘要：本文目的是了解Owin基本原理。讲述如何从控制台创建一个自宿主的OwinHost，然后再编写一两个中间件 准备工作 首先通过VisualStudio创建一个控制台应用 然后添加Owin的Nuget包引用 需要的包如下 Owin Microsoft.Owin Microsoft.Owin.Hosting Microsoft.Owin.Host.HttpListener 准备工作到此结束 编写OwinStartup类 public class Startup { public void Configuration(IAppBuilder app) { app.Run(HandleRequest); } static Task HandleRequest(IOwinContext context) { context.Response.ContentType = "text/plain"; return context.Response.WriteAsync("Hello world from myOwin"); } } 当OwinHost运行时，会首先加载Startup类，Confi...
2017-11-16
452
上一篇

打造属于自己的博客 - Asp.net三层架构

大家好，暑假过大半，不知道现在的你在做些什么，也许在苦力，也许在加班，也许在打dota，也许...在写代码。体会着属于自己的生活和理想，而我也在忙碌中迅速的往社会的方向迈进，马上毕业了，压力山大啊，找工作的话还是坚持自己心中的理想，不达目标绝不妥协！虽然有些偏激但更为自己的态度所决定，我就是这么一个人。 可能有想要表白的意愿吧，所以就在暑假工作期间萌发了写网站的想法，技术有限的我，在工作期间大量的学习和问项目总监（挺不错的一个牛x的人），花了大概一个星期就艰难的完成了博客，其实是为她而做，希望在开学的时候告诉她自己的内心的想法，并且期望自己想要的结果，所以很是努力。天在看..... 喜欢开源的东西，所以这次也就准备试一试，在前几期的博文中已经介绍了几个博客建站的必备功能的代码学习过程。这里就不多陈述了，接下来就直接进入三层的编写，表现层，业务逻辑层，数据层大家应该很熟悉了吧，如果不清楚这个过程的，百度一下，这里就不做陈述了。 下面是三层的代码和逻辑引用。举一例，用户信息的三层代码： Model： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 1...
2017-11-16
631
下一篇

相关文章

发表评论

资源下载

更多资源
腾讯云软件源

腾讯云软件源

为解决软件依赖安装时官方源访问速度慢的问题，腾讯云为一些软件搭建了缓存服务。您可以通过使用腾讯云软件源站来提升依赖包的安装速度。为了方便用户自由搭建服务架构，目前腾讯云软件源站支持公网访问和内网访问。

时间: 2025-12-28 大小: 1MB 下载: 4次
Nacos

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

时间: 2025-12-21 大小: 189MB 下载: 2次
Spring

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。

时间: 2025-12-17 大小: 5MB 下载: 1次
Rocky Linux

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。

时间: 2026-01-03 大小: 1.42GB 下载: 2次
手机查看

扫码在手机上查看文章

扫描二维码，手机阅读更方便

热门标签
SpringBoot4 OpenAi DeepSeek Gemini3 Docker Kubernetes Service Mesh HarmonyOS6 SpringCloud Nacos3 Redis Jdk25 Rocky

欢迎您来访！

登录后，您将获得更多功能！
热门文章
联系我们

有任何问题或合作意向欢迎联系我们

Email: 99873273@qq.com

QQ: 99873273

用户登录
用户注册