Summary of commonly used asp.net skills

vs2005 Common shortcut keys

DebuggingShortcut keys

F6: Generate solution
Ctrl+F6: Generate current project
F7: View code
Shift+F7: View the form designer
F5: Start debugging
Ctrl+F5: Start execution (without debugging)
Shift+F5: Stop debugging
Ctrl+Shift+F5: Restart debugging
F9: Switch breakpoints
Ctrl+F9: Enable/stop breakpoints
Ctrl+Shift+F9: Delete all breakpoints
F10: Process by process
Ctrl+F10: Run Go to the cursor
F11: Statement by statement

Edit shortcut keys

Shift+Alt+Enter: Switch to full-screen editing

Ctrl+B,T / Ctrl+K, K: Toggle bookmark switch
Ctrl+B,N / Ctrl+K,N: Move to next bookmark
Ctrl+B,P: Move to previous bookmark
Ctrl+B,C: Clear all Tags

Ctrl+I: Incremental search
Ctrl+Shift+I: Reverse progressive search
Ctrl+F: Find
Ctrl+Shift+F: Find in files
F3: Find next
Shift+F3: Find previous
Ctrl+H: Replace
Ctrl+Shift+H: Replace in file
Alt+F12: Find symbol (list All search results)

Ctrl+Shift+V: ClipboardLoop

Ctrl+left and right arrow keys: move one word at a time
Ctrl+up and down arrow keys: scroll code screen, but does not move the cursor position.
Ctrl+Shift+L: Delete the current line
Ctrl+M,M: Hide or expand the currently nested fold State
Ctrl+M,L: Set all processes to The same hidden or expanded state
Ctrl+M,P: Stop outline display
Ctrl+E,S: View blank
Ctrl+E,W: Automatically wrap lines
Ctrl+G: Go to specified Row
Shift+Alt+arrow keys: Select rectangular text
Alt+left mouse button: Select rectangular text

Ctrl+Shift+U: Change all to uppercase
Ctrl +U: Change all to lowercase

Code shortcut keys

Ctrl+J / Ctrl+K,L: List members
Ctrl+Shift+Spacebar/Ctrl+K,P: Parameter information
Ctrl+K,I: Quick information

Ctrl+E,C / Ctrl+K,C: CommentsSelected content
Ctrl+E,U / Ctrl+K,U: Deselect comment content

Ctrl+K,M: Generate method stub
Ctrl+K,X: Insert code segment
Ctrl+K,S: Insert outside code

F12: Go to the definition of the called procedure or variable

Window shortcut key

Ctrl+W,W: Browser window
Ctrl+W,S: Solution Manager
Ctrl+W,C: ClassView
Ctrl+W,E: Error List
Ctrl+W,O: Output View
Ctrl+W,P: PropertiesWindow
Ctrl+W,T: Task list
Ctrl+W,X: Toolbox
Ctrl+W,B: Bookmark window
Ctrl+W,U: Document outline

Ctrl+D,B: Breakpoint window
Ctrl+D,I: Immediate window

Ctrl+Tab: Active window switching

Ctrl+Shift+N: Create a new project
Ctrl+Shift+O: Open the project
Ctrl+Shift+S: Save all
Shift+Alt+C: Create a new class
Ctrl+Shift+A: New item



3. Variable.ToString()
Character type conversion to String
12345.ToString("n"); //Generate 12,345.00
12345.ToString("C"); //Generate ￥12,345.00
12345.ToString("e") ; //Generate 1.234500e+004
12345.ToString("f4"); //Generate 12345.0000
12345.ToString("x"); //Generate 3039 (hexadecimal)
12345. ToString("p"); //Generate 1,234,500.00%

1.9 Get the Chinese date display - year, month, day, hour and minute
string strY=currentTime. ToString("f"); //Do not display seconds

1.10 Get Chinese date display_year and month
string strYM=currentTime.ToString("y");

1.11 Get Chinese Date display_month and day
string strMD=currentTime.ToString("m");

1.12 Get Chinese year, month and day
string strYMD=currentTime.ToString("D");

1.13 Get the current time and minute, the format is: 14:24
string strT=currentTime.ToString("t");

1.14 Get the current time, the format is: 2003-09-23T14:46 :48
string strT=currentTime.ToString("s");

1.15 Get the current time, the format is: 2003-09-23 14:48:30Z
string strT=currentTime.ToString ("u");

1.16 Get the current time, the format is: 2003-09-23 14:48
string strT=currentTime.ToString("g");

1.17 Get the current time in the format: Tue, 23 Sep 2003 14:52:40 GMT
string strT=currentTime.ToString("r");

1.18 Get the date and time n days after the current time
DateTime newDay = DateTime.Now.AddDays(100);



String variable.Replace("substring","replace with")
String replacement
Such as:
string str="China";
str=str.Replace("国","central"); //Replace the character "国" with the character "central"
Response.Write(str); //The output result is "central"



C#ProgrammingNorms
It is extremely necessary to develop a good coding style. No one wants to see a bunch of messy code that you or others will maintain in the future. So, from now on, develop good coding habits, including variable naming, comments, code indentation....
1. Use Pascal's method to define types, method names and constants

public class SomeClass
{
const int DefaultSize=100;
public SomeMethod()
{
}
}

2. For local variables and methods Parameters use camel nomenclature

##int number;

##3.
The name of the interface
is preceded by I

##interface ImyInterface

4. Add m_ in front of the private member variables. For the

variable name
after m_, use the camel naming method

##public class SomeClass

                                                                                                                                   Use the camel naming method ##       }

#5. Add the suffix Attribute to the custom attribute class Object pairs, such as ShowDialog()

6. Add the suffix to the custom exception class
Exception


7. Method naming uses verbs----

8. Methods with return values There should be a description of the return value in the name, such as GetObjectState()

9. Use descriptive variable names
a) Avoid single-character variable names, such as I or t, etc. Use meaningful names like index or temp. b) Avoid using Hungarian notation for variables of public or protected type. c) Do not abbreviate words (for example, use num instead of number).

10. Always use C# predefined rather than using aliases in the System namespace, for example: Use object instead of Object Use string instead of String
Use int instead of int32

11. When using generics, the first letter of the type must be capitalized. When dealing with Type types in .NET, retain the Type suffix. (New features of C#2.0)




##//Correct
              public class LinkedList #// Avoid
Public Class LinkedList & LT; KeyType, DATATYPE & GT;
{….}


## 12. Use meaningful names to define name space space space , such as product name or company name

13. Avoid using type names in fully qualified ways and use the using keyword. 14. Avoid using the using keyword in a namespace using System.Collection.Generic; using System.ComponentModel; using System.Data;

15. Organize all the namespaces provided by the system
framework
and group the names provided by third parties Place the space below the system namespace




##using System;

using MyCompany;

using MyControls;




##16. Use proxy deduction instead of explicitly instantiating an agent (New features in C#2.0)

##delegate void SomeDelegate();             public void SomeMethod()                                                                                                                                                                             to                                           –                     # =SomeMethod;

17. Maintain strict code indentation. Do not use tabs or non-standard indentation, such as a space. The recommended indentation is 3 to 4 spaces.

18. Comment out the line of code at the same level as your code indentation.

19. All comments should pass spell check. Misspellings in comments mean delays in development progress.

20. All class member variables should be declared at the top of the class, and use a blank line to separate them from method and attribute declarations

21. Declare a local variable closest to where it is used. 22. A file name should reflect the class name it corresponds to

public class MyClass
                                                                                                                                                        int m_Number; d2();
    }

23. When using a partial class and distributing the class to different files, in each file name At the end, add the role that the implementation part of the file plays in the overall class. For example:




##// In MyClass.cs

public partial class MyClass {…} //In MyClass.Designer.cs PUBLIC PARTIIL CLASS MyCLASS

{…}



## 24. Always put the flames "{" in the new line

Coding Practice

:
1. Avoid placing multiple classes in the same file2. A file should only define types in one namespace . Avoid using multiple namespaces in one file3. Avoid writing more than 500 lines of code in a file (except automatically generated code by the machine)4. Avoid writing more than 25 lines of code
5. Avoid writing methods with more than 5 parameters. If you want to pass multiple parameters, use a structure.
6. One line should not exceed 80 characters
7. Do not manually modify any machine-generated code
a) If you modify the machine-generated code, modify your encoding method to adapt to this encoding standard
b) Use partial classes features as much as possible to improve maintainability. (New features in C# 2.0)
8. Avoid commenting on content that is very intuitive. The code itself should be able to explain its own meaning. Good code consisting of readable variable and method names should not require comments.
9. Comments should only describe some prerequisite assumptions of the operation, internal information of the algorithm, etc.
10. Avoid commenting methods
a) Use sufficient external documentation to describe
API

b) Only information that is useful to other developers is necessary to be placed in methods Level comments
11. Never hardcode values ​​other than 0 and 1, by declaring a constant instead 12. Only use the const key for values ​​that will never change Word
, such as the number of days of the week.
13. Avoid using the const keyword for read-only variables. In this case, use the readonly keyword directly


##public class MyClass

                                                                                                                                                                                                                          to be used directly. readonly int Number; public MyClass(int someValue) { Number=someValue; Debug .assert(someObject!=null);

## 14. Make an assertion for each hypothesis. On average, there should be one assertion every 5 lines.




##using System.Diagnostics;
object GetObject()
{…}
object someObject=GetObject();

15. Every line of code should be reviewed through white-box testing.
16. Only catch exceptions that you can explicitly handle yourself.
17. If you need to throw an exception in the catch statement block, only throw the exception captured by the catch (or other exceptions created based on the exception), so that the original error can be maintained The stack location where it is located.

##catch(Exception exception) 18. Avoid using return values ​​as error codes for functions

    }

.

19. Avoid custom exception classes.
20. When customizing exception classes: a) Let your custom exception class inherit from the Exception class

b) Provide a custom serialization mechanism21. Avoid defining multiple Main
() methods in one assembly.
22. Only define those methods that are absolutely necessary as public, and define other methods as internal.
23. Avoid friend assemblies, because this will increase the coupling between assemblies. 24. Avoid making your code dependent on an assembly running in a specific place. 25. Minimize the amount of code in application assembly (EXE client assemblies). Use class libraries to contain business logic.
26. Avoid explicitly specifying the value of an enumeration

##//Correct           public enum Color                                                                    ,Blue } //Avoid

                                                                                                   
                                                                 }





27. Avoid specifying a type for an enumeration

Public enum Color:long

                                                                                                                                                                                                                        Contain it, even if it's just one statement.
29. Avoid using ternary conditional

operators. 30. Avoid using Boolean values ​​returned by functions as conditional statements. Assign the return value to a local variable and then test it.                                                                                                                                                                              ##31. Always use zero-based arrays.

##Bool IsEverythingOK()
…}

32. Always use a

for loop
to explicitly initialize an array that references members:

public class MyClass

                                                                                                                                                               const int ArraySize=100;
{
array [index] = new myclass ();
}



#

33. Use properties to replace public or protected type member variables.
34. Do not use the inherited new operator, use the override keyword to override the implementation of new.
35. In a non-sealed class, always define public and protected methods as virtual.
36. Never use unsafe code except to interact with other languages.
37. Avoid displaying type conversion. Use the as keyword to safely convert to another type.

##Dog dog=new GermanShepherd();

GermanShepherd shepherd=dog as GermanShepherd;
if (shepherd!=null)
{ …}

#38. Before calling a proxy, always check if it is null.

39. Do not provide public
event member variables. Use Event Accessor instead.

#Public class MyPublisher                                       Add                                                                            } 49. Expose interfaces in class inheritance structures. 50. It is recommended to use explicit interface implementation. 51. Never assume that a type supports an interface. Always ask before using.

                         
                                                                                  

#40. Avoid defining
event handling
proxies. Use EventHandler or GenericEventHandler.
41. Avoid displaying trigger events. Use EventsHelper to publish events safely.
42. Always use interfaces.
43. The ratio of methods and properties in interfaces and classes should be around 2:1.
44. Avoid interfaces with only one member.
45. Try to ensure that an interface has 3~5 members.
46. Do not let the number of members in an interface exceed 20, while 12 is a more practical limit.
47. Avoid including events in interfaces.
48. When using
abstract class
, provide an interface.

##SomeType obj1;
ImyInterface obj2;
/*Some code to initialize obj1,then:*/
obj2=obj1 as ImyInterface ;
                                                                                                                                                                                                                      //Handle erro in expected                                                               



#52. Do not hardcode the strings displayed to the user. To use resources.
53. Do not hardcode strings that may change with the release environment, such as database connection strings.
54. Use String.Empty instead of ""

//Avoid
          string name=""; # string name=String.Empty;

55. When using a long string, use StringBuilder instead of string.
56. Avoid providing methods in structures
a) Parameterized constructors are encouraged to be used
b) Can overload operators
57. When declaring expressive members, always provide a expressive constructor.
58. Try not to use late-binding when early-binding is possible.
59. Make your application support tracing and logging.
60. Do not use the goto keyword except to implement code jumps in the switch statement block.
61. Always provide an assertion in the default case of a switch statement.

##int number=SomeMethod(); Case 1:")             public MyClass():this(“Hello”)                                                                           ’s ’’s }                 ‐     ‐ ‐‐ ‐‐‐‐ public MyClass():this(“Hello”) ​            Access members of the base class, unless you are trying to resolve a subclass name conflict when calling a base class constructor

break;
case 2:
trace.Writeline("Case 2:");
break;
default:
debug.Assert(false);
            break;




##//Example of proper use of 'this'
          public class MyClass  
                                                                                                        use ’ ’ ’ using using ’'s ’ ‐ ‐ ‐ ‐ ‐ public class MyClass                                                        { }

//Example of proper use of 'base' public class Dog public Dog(string name) # This 64. Do not use gc.addMemoryPressure () 65. Do not rely on handlecollector

{ } virtual public void Bark(int howlong)
                                                                                                                 public class GermanShepherd:Dog
{    
               base.Bark( Howlong)
}
}

66. Implement the Disponse() and Finalize() methods based on the content of Chapter 4 in "Programming .NET components" 2/e.

67. Always run code in unchecked state (for performance reasons), but to prevent overflow or underflow operations, use checked mode decisively.

##Int CalcPower(int number,int power)

;=power;count++)
                                                  
                                                                  return result;

68. Use conditional methods to replace explicit method call exclusion code (#if...#endif)

##public class MyClass #Public class Customer ; constraint.

                                                             
                                                                                                                                                                                                                                                                                                 
Constraints
are defined in the generic interface. Interface-level constraints can often be replaced by strong typing.

71. Do not define constraints on agents.

72. If a class or method provides generic and non-generic versions, the generic version is preferred

-->

The above is the detailed content of Summary of commonly used asp.net skills. For more information, please follow other related articles on the PHP Chinese website!