. NET10 Programming Experience Skills

1. Minimize form Loopback

Whenever you click a button, LinkButton, or ImageButton control on a Web page, the form is sent to the server. If the control's AutoPostBack property is set to True, the form is sent back to the server if the state of the checkbox, CheckBoxList, and so on is changed.

Each time the form is sent back to the server, it is reloaded, starts page_load****, and executes all the code in the page_load**** handler. It is most appropriate to put the initialization code of the Web page here. We often want to execute some code every time we load a Web page, but we want to execute some code when the page first loads, and even want some code to execute on every load except for the first load.

You can use the IsPostBack feature to do this. The value of this property is false the first time the page is loaded. If the page is reloaded by loopback, the value of the IsPostBack property is set to true. By testing, you can execute the specified code at any time. The following is the related C # code:

The following are the referenced contents:

protected void Page_Load (Object sender, EventArgs e)
{
Some of the actions that are performed each time a Web page is loaded
if (! IsPostBack)
{
What to do when a Web page is loaded for the first time
}
Else
{
Actions to perform when loopback
}
What to do when a Web page is loaded each time
}

2, in the use of visual Studio. NET, do not use the default name except for objects that are directly or not referenced.

. NET, one of the benefits is that all source code and configuration files are plain text files that can be edited using any text editor such as Notepad or WordPad. If not, we are not necessarily using visual Studio. NET as an integrated development environment. But with Visual Studio. NET, we can see files in Windows File Manager, or in Visual Studio. NET to browse the contents of a file from a text editor.

Use Visual Studio. NET as an integrated development environment has many benefits, the most notable of which is that it greatly improves productivity. Use Visual Studio. NET, we are able to develop the software faster with a small cost. IntelliSense, as part of the integrated development environment, provides automatic code completion, provides dynamic help when entering methods or functions, real-time hints of syntax errors, and other features that improve productivity.

Like other complex tools, Visual Studio before learning how to give full play to its role and grasp its "habits". NET also gives us a sense of frustration. Sometimes it's like a black box that's hard to understand, generating a lot of files and lots of useless code.

Visual Studio. NET is the ability to provide a default name for a new object, whether it is a class, a control, or an object in a form. For example, if we create a new ASP.net Web application, the default name will be WebApplication1. We can easily change the name of the application in the "New Project" dialog box, but change only the name of the application's namespace and its virtual directory, the default name of the source code file is still WebForm1.aspx and WebForm1.aspx.cs (C # Engineering) Or WebForm1.aspx.vb (VB. NET project).

We can change the file name used by ASPX and code in the scenario browser, but the name of the Web page class will still be WebForm1. If a button is generated on the Web form, the default name will be Button1. In fact, the names of all controls are made up of the type and number of controls.

We can, and should, change the names of all the forms and controls in the application to meaningful names. The default name is also available for smaller demos, but if the application is composed of multiple forms, with many buttons and labels on each form, tables such as Frmstartup, Frmdataentry, and Frmreports are single-name more than Form1, Names like Form2 and Form3 are easier to understand and maintain.

If a control on a form is to be referenced elsewhere in the code, it is even more important to have a meaningful name. Names such as Btnok, Btncancel, and btnprint make it easier for people looking at the code to understand, and therefore easier to maintain than controls named Button1, Button2, and Button3.

A good way to modify a name that appears in all files in a project is to select the "edit"-> "discover and replace"-> "replace" command in the VisualStudio.NET menu. When we look at the code we wrote two weeks ago, it's often like we saw it for the first time, so it's necessary to have a name that helps us understand its meaning.

3, even if you do not use visual Studio. NET programming, using code support files can also improve the performance of your application.

In all asp.net Web projects, such as Web applications, Web services, or Web controls, Visual Studio. NET uses code support files. The code support file makes the project better organized, modular, and more suitable for the development team composed of many people. In addition, it also brings performance improvements.

The contents of the code support file are compiled into a class in a composite file, typically a DLL file, or sometimes an EXE file. The file resides in the application's assembly cache, and can be immediately available when the application starts.

If the code is contained in the < script> tag or in the ASPX file code, it will still be compiled into a Web page class. In this case, each time the page is loaded for the first time in the application dialog, it needs to be compiled again, and the compiled class resides in memory. Each time the computer starts, IIS stops, restarts, or the source code, configuration file changes, the file must be recompiled. Although not large, the resulting loss of performance is considerable.

4, the use of StringBuilder class

String in the. NET Framework, which means that changing the operator and method of a string returns a changed copy of the string, which means there is room for improvement in performance. When doing a lot of string manipulation, using the StringBuilder class is a better choice.

The following C # code tests the time that is required to generate a string from 10,000 substrings in two different ways. A simple string concatenation operation was used for the first time; the StringBuilder class was used for the second time.

To see the result string, you can remove the callout symbol for the callout line in the following code:

The following are the referenced contents:

%@ Page language= "C #"%>
Script runat= "Server"
void Page_Load (Object Source, EventArgs E)
{
int intlimit = 10000;
DateTime StartTime;
DateTime Endtime;
TimeSpan ElapsedTime;
String strsub;
String strwhole = "";
To perform a string concatenation operation first
StartTime = DateTime.Now;
for (int i=0; I intlimit; i++)
{
Strsub = i.ToString ();
Strwhole = Strwhole + "" + strsub;
}
Endtime = DateTime.Now;
ElapsedTime = Endtime-starttime;
Lblconcat.text = Elapsedtime.tostring ();
Lblconcatstring.text = Strwhole;
Doing the same thing with the StringBuilder class
StartTime = DateTime.Now;
StringBuilder sb = new StringBuilder ();
for (int i=0; I intlimit; i++)
{
Strsub = i.ToString ();
Sb. Append ("");
Sb. Append (strsub);
}
Endtime = DateTime.Now;
ElapsedTime = Endtime-starttime;
Lblbuild.text = Elapsedtime.tostring ();
Lblbuildstring.text = sb. ToString ();
}
/script>
html>
body>
Form runat= "Server"
h1>string concatenation benchmarkConcatenation:
[Aspabel id= "Lblconcat" runat= "Server"/>
br/>
[Aspabel id= "lblconcatstring" runat= "Server"/>
br/> br/>
StringBuilder:
[Aspabel id= "Lblbuild" runat= "Server"/>
br/>
[Aspabel id= "lblbuildstring" runat= "Server"/>
/form>
/body>
/html>

is nearly 200 times times faster than using string concatenation.

5. Use server-side controls only when necessary

Asp. NET, a control called Web server controls that runs on the server side is introduced, and in code, they are often illustrated by the following syntax:

< Asp:textbox id= "Txtlastname" size= runat= "server"/> They are sometimes referred to as ASP controls. The server-side control is indicated by the Runat property, and its value is always "server".

By adding the Runat property, a generic HTML control can be easily converted to a server-side run, and here's a simple example:

< input type= "text" id= "Txtlastname" size= "" runat= "Server"/>

By using the name specified in the id attribute, we can reference the controls in the program and programmatically set the properties and get the values, so the server-side approach has greater flexibility. There is a certain cost to this flexibility. Each server-side control consumes resources on the server. In addition, unless the control, Web page, or application explicitly prohibits view state, the control's status is contained in the hidden field of view, and is passed in each loopback, causing severe performance degradation.

A good example of this is the application of a control table on a Web page that uses HTML tables that do not require server-side processing if you do not need to refer to elements in the table in your code. We can still place the server control in the HTML table cell and reference the server control in code. If you need to refer to any table element, such as a specified cell, the entire table must be a server control.

6. Differences between hyperlink controls, LinkButton controls

HyperLink, LinkButton controls are the same for web visitors, but they still differ significantly in functionality. When a user clicks on a control, the hyperlink control immediately "navigates" the user to the destination URL, and the table is not echoed to the server. The LinkButton control first sends the table back to the server and then navigates the user to the target URL. Use the LinkButton control if server-side processing is required before reaching the target URL, or you can use the hyperlink control if you do not need server-side processing.

7. Annotation Code

This technique is not aimed at asp.net, but it is a good programming habit. Comments should not only explain what the code does, but should also indicate why. For example, instead of just stating in a comment that you are traversing an array, you should explain that the traversal array calculates a value based on an algorithm, unless the algorithm is fairly simple, otherwise the algorithm should be briefly described.

. NET project different programming languages have their own different annotation symbols, the following is a brief description:

The following are the referenced contents:

HTML <!--notes-->javascript//Notes VBScript ' comments vb.net ' comments C #//comments//Multiple-line comments/*
SQL--Comments
There is no annotation symbol in the start and end tag of the server control, but the server can ignore all properties it does not recognize, so we can insert the annotation by using a property that is not defined. Here is an example:

< Asp:textbox id= "Txtlastname" size= "comment=" This is my comment runat= "server"/>
In Visual Studio. NET is very simple to annotate the source code. Highlight the line you want to comment on, and then press Ctrl+k+c to add a comment. To remove a comment, simply display the annotated code with a high brightness and press the Ctrl+k+u key combination.

In C # Engineering, we can also enter XML annotation bars by using///at the beginning of each line.

In the annotation section, we can use the following XML markup to organize comments:

The following are the referenced contents:

< summary></summary>
< remarks></remarks >
< param></param>
< returns></returns>
< newpara></newpara>

To be in visual Studio. NET to view the formatted report of these XML annotations, we can first select the Tools menu item and then select the Create Comment Web page menu item.

8. Use the trace method and trace property to record the execution of pages in the page directory

One of the oldest techniques for debugging is inserting output statements at a key point in the program, where the output information contains the value of the important variable, and the information can be exported to the screen, log file, or database.

In asp.net, this debugging technique is easier to use by using the Trace attribute in the page command. The page command is a line of code at the beginning of the ASPX file, which provides instructions for the compiler. The page command contains one or more properties that provide the compiler with information such as the programming language used, the location of the code support file, or the name of the class to inherit.

One of the properties in the page command is trace, whose value may be true or false, and the following is a typical page command where the value of the Trace property is true:

<%@ Page language= "C #" trace= "true"%>

If the value of the Trace property is set to True, the Web page generated by the ASPX file is displayed, and a large amount of additional information about the page is displayed in addition to the page itself. This information is displayed in a table in the following sections:

· The request details provide the session ID, the requested time, and the status code of the request.

· Trace information contains a list of trace logs, chronological steps in the Web page life cycle. Alternatively, you can add custom information to it.

• The control tree lists all the controls on a Web page in a hierarchical fashion, including the size of each control in bytes.

· The Cookies collection lists all cookies created by the Web page.

• Head collection HTTP headers and their values.

· The server environment variable that the server variable is associated with for this page.

The trace logs contained in the trace Information section are most useful, where we can insert our own tracking commands. There are 2 methods in the Trace class that can insert a command in the trace log:

Trace.Write and Trace.Warn, except the Trace.Warn commands are displayed in red font. Trace.Write commands are displayed in black font, they are the same. Below is a screenshot of the trace log, which contains several Trace.Warn commands.

The most convenient feature in the trace log is that we can insert trace.write and Trace.Warn statements throughout the code during development and testing, and when the application is finally delivered, you can prevent these commands from working by changing the value of the trace property in the page command, without having to remove the output language before deploying the application software Sentence

9. Using Stored Procedures

Microsoft's SQL Server and other modern relational databases use SQL commands to define and process queries. A SQL statement or a series of SQL statements submitted to SQL Server,sql Server resolves the command, then creates a query plan and optimizes it, and then executes the query plan, which takes a lot of time.

A stored procedure is a series of SQL commands that are resolved and optimized by a query processor that is stored and executed quickly.

Stored procedures are also called SPROCs, which can receive input parameters so that a single stored procedure can handle a larger range of specific queries.

Because sprocs are resolved in advance and are more important for complex queries, their query plans are optimized, so invoking the query process is much faster than SQL statements that perform the same functions.

10, use. NET command line

. NET command-line tool runs in a command prompt window. In order for the command to execute, it must reside in the current directory at the command prompt, or by setting the PATH environment variable.

The. NET SDK installs a menu item on the Startup menu that opens a command prompt window that correctly sets the PATH environment variable. We can click "Start"-> "program"-> "Microsoft Visual Studio. NET"-> Visual Studio. NET tool "->" Visual Studio. NET command prompt, and start a command prompts window.

By pressing CTRL + C while you drag the menu item from the menus to the desktop, you can copy the menu item's shortcut to the desktop, which is convenient to use.