Recognize web design patterns

The core code written by hiding the function using the VS.NET code is as follows:

Rear code (WebMM.ASPX.CS):

// Page initialization event

Private Void Page_Load (Object Sender, System.EventArgs E)

{

IF (! ispostback)

{

String SQL_SELECT_PORTAL = "SELECT * from Portal";

// Use using to ensure the release database connection

/ / Connection string is placed in a web.config file to facilitate modification

Using (SqlConnection Conn = New SqlConnection (ConfigurationSttings.AppSettings ["Connectionstring"]) {

SqlDataAdapter DataAdapter = New SqlDataAdapter (SQL_SELECT_PORTAL, CONN);

DataSet DataSet = New DataSet ();

DataAdapter.Fill (DataSet);

/ / Set the data source of the drop-down list with text domain, value domain

DropdownList.DataSource = DataSet;

DropDownList.DataTextField = "PortalName";

DropdownList.DataValuefield = "portalid";

DropDownList.DATABIND ();

}

}

}

// Button's Click event

Private void Button_Click (Object Sender, System.Eventargs E)

{

String SQL_SELECT_SUBJECT = "SELECT * from Subject WHERE Portalid = {0}";

Using (SqlConnection Conn = New SqlConnection (ConfigurationStings.AppSettings ["Connectionstring"]))

{

// Replace the pending character {0} in the SQL statement with the value selected by the drop list.

SqldataAdapter DataAdapter = new sqldataadapter (String.Format (SQL_SELECT_SUBJECT, DROPDOWNLIST.SELECTEDVALUE), CONN);

DataSet DataSet = New DataSet ();

DataAdapter.Fill (DataSet);

DataGrid.datasource = dataset;

DataGrid.databind ();

}

}

The execution result is as shown in the figure, the program will bind DataGrid according to the value selected by the drop-down list box, which reflects the idea of ​​ASP.NET event driver, and implements the separation of the interface and code. But take a closer look, you can find a few questions:

 Repeat the code of the database, duplicate code is the absolute "bad taste" in software development, often because of some reason, when you modify a code, forget to change the same code, thus leave the program The hidden danger of bug.

 The rear code is completely dependent on the interface. The changes in the WebForm are far greater than the change in data storage structure and access. When the interface changes, you will have to modify the code to accommodate the new page, it is possible to rewrite the whole Set code.

 The rear code not only handles the user's input but also the processing of the data. If the demand changes, for example, you need to change the processing method of data, then you will almost rewrite the entire post code.

A excellent design requires every module, each method is only focused on doing something, such a structure is clear, easy to modify, after all, the demand for the project is constantly changing, "The only constant is the change itself" Good procedures must be prepared for changes, avoid "moving the whole body", so we must find ways to solve the above problems, let us take a look at the design model.

Design Patterns

Design patterns describe a continuous repeated problem and a core solution for this issue, which is a successful architecture, design and implementation plan, is a summary of experience. The concept of design patterns came earlier from Western architecture, but the most successful case was first pushed in ancient China's "36). WebForm in MVC mode

The MVC mode is a basic design pattern for separating user interface logic to business logic, which divides data processing, interface, and user behavior control: Model-View-Controller.

 MODEL: responsible for the current application data acquisition and change and related business logic

 View: Responsible for display information

 Controller: Responsible for collecting input to transformation users

VIEW and Controller are dependent on Model, but Model does not depend on View, nor does it depend on Controller, which is one of the main advantages of separation, so Model can establish and test separately for code multiplexing, View and Controller only need MODEL provides data, they will not know, nor is it that data is stored in SQL Server or any place in an Oracle database.

According to the idea of ​​MVC mode, the back code of the above example can be split into Model and Controller, with a special class to process data, and the rear code is only responsible for converting the user's input as Controller, and the modified code is:

Model (SQLHELPER.CS): Pack all the operations of the database.

Private static string SQL_SELECT_PORTAL = "Select * from portal";

Private static string sql_select_subject = "SELECT * from Subject where portalid = {0}";

Private static string SQL_CONNECTION_STRING = ConfigurationSettings.AppSettings ["Connectionstring"];

Public Static Dataset getPortal ()

{

Return getDataSet (SQL_SELECT_PORTAL);

}

Public Static DataSet GetSubject (String Portalid)

{

Return getDataSet (String.Format (SQL_SELECT_SUBJECT, PORTALID);

}

Public Static DataSet getDataSet (String SQL)

{

Using (SqlConnection Conn = New SqlConnection))

{

SqlDataAdapter DataAdapter = New SqldataAdapter (SQL, CONN);

DataSet DataSet = New DataSet ();

DataAdapter.Fill (DataSet);

Return DataSet;

}

}

Controller (WebForm.aspx.cs): Responsible for transforming users' input

Private Void Page_Load (Object Sender, System.EventArgs E)

{

IF (! ispostback)

{

// Call the MODEL method to get the data source

DropdownList.DataSource = SQLHELPER.GETPORTAL ();

DropDownList.DataTextField = "PortalName";

DropdownList.DataValuefield = "portalid";

DropDownList.DATABIND ();

}

}

Private void Button_Click (Object Sender, System.Eventargs E)

{

DataGrid.datasource = SQLHELPER.GETSUBJECT (DropDownList.SelectedValue);

DataGrid.databind ();

}

The modified code is very clear, and the M-V-C has made the other module rewriting causes changes in other modules, similar to the DOC / View structure in the MFC. But if the same structure has a lot of procedures, we need to do some unified controls, such as user identity, unified interface style, etc .; or you want Controller to separately separate, not involving Model layers in Controller Code. At this time, just rely on the MVC mode, you will be a bit of strength, then take a look at the Page Controller mode below.

WebForm in Page Controller

The MVC mode mainly focuses on the separation between Model and View, and less concerned about Controller (in the above MVC mode, we only leave Model and Controller, do not process Controller), but based on In WebForm's applications, View and Controller have been separated (the display is performed in the client browser), and the controller is a server-side application; while different user operations may cause different Controller policies, the application must be based on One page and user triggering events to perform different operations; there are many webforms that require a unified interface style, and if it is not possible to generate duplicate code, it is necessary to make CONTROLLER more carefully divided.

Page Controller Mode Based on the MVC mode, use a public page base class to unify the like, such as HTTP requests, interface style, etc.

Traditional WebForm typically inherits from the System.Web.ui.page class, and the implementation of the Page Controller is that all WebForm inherits the custom page base class, as shown:

With the custom page base class, we can unify the page request, extract all related data, call all updates to Model and forward the request to the View, and easily implement the unified page style, and the logic of the Controller it derived will change It is simpler, more specific.

Let's take a look at the specific implementation of Page Controller:

Page controller (Basepage.cs):

Public class basepage: System.Web.ui.page

{

Private string_title;

Public String Title // Page title, responsible for subscribers

{

get

{

Return_title;

}

set

{

_title = value;

}

}

Public DataSet GetportalDataSource ()

{

Return SQLHELPER.GETPORTAL ();

}

Public DataSet GetSubjectDataSource (String Portalid)

{

Return Sqlhelper.getsubject (portalid);

Protected Override Void Render (HTMLTextWriter Writer)

{

Writer.write ("