打印

<<C#编码标准>>

SEVENLU

助理工程师

Rank: 2

发短消息
加为好友
当前离线

1^# 大中小发表于 2007-3-10 22:32 只看该作者

<<C#编码标准>>

C#编码标准－－编码习惯

1.  避免将多个类放在一个文件里面。
7 {; h1 q% m6 F0 r; o/ ~
2.  一个文件应该只有一个命名空间，避免将多个命名空间放在同一个文件里面。5 e+ P' q7 G7 S- v- }# v' e
4 g# f- T  q9 x% N
3.  一个文件最好不要超过500行的代码（不包括机器产生的代码）。

4.  一个方法的代码长度最好不要超过25行。

5.  避免方法中有超过5个参数的情况。使用结构来传递多个参数。
$ _, n  W9 [% T. t9 a6 L! h+ U' f  Y
6.  每行代码不要超过80个字符。
0 s2 X/ B5 X& K  x7 ^5 P
7.  不要手工的修改机器产生的代码。
! `; @' z, h" s
a)  如果需要编辑机器产生的代码，编辑格式和风格要符合该编码标准。
/ {. v2 e# T+ u& Y! V
b)  Use partial classes whenever possible to factor out the maintained portions.
5 q; Q0 ?  c9 Z# X
8.  避免利用注释解释显而易见的代码。8 f6 |8 A' B5 s# ^  g$ t2 q% t
  q, {0 ?* J- U# g3 F, t8 M
a)  代码应该可以自解释。好的代码由可读的变量和方法命名因此不需要注释。

9.  Document only operational assumptions, algorithm insights and so on.
$ J, E( g% {+ ^8 V9 x
10.  避免使用方法级的文档。" R/ Q1 k5 O5 t! Y7 U8 a  x

a)  使用扩展的API文档说明之。
2 Q+ X6 m2 D! e! g
b)  只有在该方法需要被其他的开发者使用的时候才使用方法级的注释。（在C#中就是///）
( m0 B3 }* Y- O/ X! Z9 g
11.  不要硬编码数字的值，总是使用构造函数设定其值。

12.  只有是自然结构才能直接使用const，比如一个星期的天数。" T5 Y* D% u% z# y3 i3 S9 W, ~' y

13.  避免在只读的变量上使用const。如果想实现只读，可以直接使用readonly。) b( o# v# B3 H, a& T& l2 N: ?: }
# H" M7 t& P9 ~
public class MyClass * J, [  ]5 y. A8 e
$ S( A6 t& H! o% |/ x; _0 S3 u: C
{
# m$ Z7 A/ ~' h
public readonly int Number; ' k5 V. `5 Q7 o3 a2 o
( l) U$ V# F  O" x1 b
public MyClass(int  someValue)
: S- R, s* W( H; y7 l6 F. x
{
' j! E/ z( v5 p  g* M4 @1 ]# U" a
   Number = someValue;
( e% ]+ |; d/ d
}

public  const int  DaysInWeek = 7;

} : _/ n+ ]* `$ y4 F5 ]5 s6 b

14.  每个假设必须使用Assert检查
% X2 \0 z$ o1 i# z8 [+ J
a)  平均每15行要有一次检查(Assert)

using System.Diagnostics;

- k. |8 u% M& w' x# A/ f  V& Q
object GetObject() : a4 X. S1 c+ b0 e* I
% [9 }& L7 O1 T1 j) k
{…}
4 w- Z/ u7 Z! E, Z
, j. r7 l8 o1 U/ t5 F5 [! L
% U- }1 f2 u/ ~! j$ Y" k
object obj = GetObject(); ; o! F- D. z3 L! H, J" |
( G/ o$ r$ I. k) _
Debug.Assert(obj != null);

15.  代码的每一行都应该通过白盒方式的测试。6 O) W$ r' T; ^9 [6 \+ B

16.  只抛出已经显示处理的异常。6 |4 d. j0 {+ u: _9 A2 `* d

17.  在捕获(catch)语句的抛出异常子句中(throw)，总是抛出原始异常维护原始错误的堆栈分配。

catch(Exception exception) 7 l$ ?" S5 b! b# ^" }' E; \
+ t; l! V6 p7 }9 @' a2 I; n
{
" j( Y/ j' A6 s' i. C$ u$ ?
MessageBox.Show(exception.Message);
$ N; r6 B% q: \/ b% x. Z
throw ;  //和throw exception一样。 0 S9 r& _) ?& p* o0 H
' l7 ]- ?9 ?6 F4 f/ _
}
1 s8 V4 D+ R3 m& ~$ o
18.  避免方法的返回值是错误代码。7 B  {; Z/ c5 \# M2 L6 j$ S) T

19.  尽量避免定义自定义异常类。

20.  当需要定义自定义的异常时：0 s6 W) G+ o) x/ h; b! W

a)  自定义异常要继承于ApplicationException。
0 i2 q+ X' B0 N
b)  提供自定义的序列化功能。7 Q2 C" E7 n. u( j# I* b/ p" g# h$ N

21.  避免在单个程序集里使用多个Main方法。( q: g  z1 n7 q' X- X

22.  只对外公布必要的操作，其他的则为internal。

23.  Avoid friend assemblies, as it increases inter-assembly coupling.
# q$ v; D" h9 T9 \$ m$ N$ w- S
24.  Avoid code that relies on an assembly running from a particular location.

25.  使应用程序集尽量为最小化代码(EXE客户程序)。使用类库来替换包含的商务逻辑。" e' `- W5 N# U
% |6 n2 Y. \  |4 |* m
26.  避免给枚举变量提供显式的值。

//正确方法    m7 S2 E1 {$ u
- S( [7 `- d+ u4 `4 c% T
public enum Color # N) G6 F. q. _! B
6 p" n; K2 }8 }! H2 T5 b+ c
{
- @/ H3 Q- f% X; p# v
Red,Green,Blue

} : E) _8 D5 A# p' }- G
3 ?7 m+ l: j3 X4 X- }& x  V1 B
//避免
5 A% y4 N; B4 i* c! K- p
public enum Color
; g  l/ k+ Q' u/ W. v% C
{ 6 J( u" d/ J4 L
1 r2 w" G8 E! _- m1 ^
Red = 1,Green =  2,Blue = 3

}

27.  避免指定特殊类型的枚举变量。2 a1 }. x' o2 N3 W4 p1 L' s

//避免
- C7 g  J6 g# ]( u
public enum Color  : long

{
' j9 r9 n+ I8 j; G
Red,Green,Blue 5 F' v5 p' m  N, G3 r! @
9 a+ L' F, w! l
} 4 |( b$ J2 r* e* Y$ i
, ^5 M8 [; t6 p3 f
28.  即使if语句只有一句，也要将if语句的内容用大括号扩起来。
7 n+ K1 P! J0 L  T* q7 X
29.  避免使用trinary条件操作符。0 b: D1 U( d1 t% E; O# W2 P6 D

30.  避免在条件语句中调用返回bool值的函数。可以使用局部变量并检查这些局部变量。

bool IsEverythingOK()
  m' [, Z. @4 S/ ?8 q5 c
{…} - w) T! {' s4 E; @

//避免 5 {4 t7 \, C) t; S$ J1 Q
, N  z% S5 p! n# E/ F) S& @; \
if (IsEverythingOK ())
! y! z8 a5 r- I; r% P6 o. z1 n  w/ O
{…}
: s( R4 Z; ~$ i4 h* {& A# c
//替换方案
6 g6 T9 ?4 e4 g1 k
bool ok = IsEverythingOK();
- T; q  U: a+ o, z& K* Z9 X( Q5 D$ A
if (ok) 3 c' B) A3 J: M; i5 V9 {
/ w) e" h6 r- U
{…} 2 k% h7 w" B  f4 D* X' k  D
2 o5 O8 \: j4 t, i! I2 Z2 e1 D
31.  总是使用基于0开始的数组。
+ ^' B9 V+ y: _. A
32.  在循环中总是显式的初始化引用类型的数组。, V; S# P6 h- o! m- w
- f4 w. X9 Q4 ^  g$ B; t# S
public class MyClass ; \2 E7 r; K; T$ A6 V4 c5 {1 g

{} - Z7 K1 z$ A* g4 [5 K5 r7 B& z" p7 Y

MyClass[] array = new  MyClass[100]; % D* a1 E0 u; n' m

for(int index = 0; index < array.Length;  index++)
5 W* ]0 g2 s: a# [* \
{
$ @. w7 `) O% j% g- M
array[index] = new  MyClass(); " M& y; f' U: t2 U4 F$ P- u
; s* ~  W( }6 p& c
} * ?7 _: d  y6 W/ @/ N5 _

33.  不要提供public 和 protected的成员变量，使用属性代替他们。

34.  避免在继承中使用new而使用override替换。* }) z1 f! X; g
) f" Z; T% n8 m. l2 ]  g
35.  在不是sealed的类中总是将public 和 protected的方法标记成virtual的。
9 m1 E! n4 C5 _/ k1 F
36.  除非使用interop(COM+ 或其他的dll)代码否则不要使用不安全的代码(unsafe code)。, }/ ~  c+ ]7 s6 x1 Z5 Y- C8 K2 u* s

37.  避免显示的转换，使用as操作符进行兼容类型的转换。: j. {6 f. ^  g* w9 y1 O

Dog dog = new GermanShepherd();
/ Y% z% [* Z' [6 q5 v
GermanShepherd shepherd = dog  as  GermanShepherd; * x! [+ y. d, m8 t7 u0 {
3 M. S; n- ^- R+ [& e2 Y; I
if (shepherd != null )
) W+ a$ I: I! b6 C1 |. r
{…} 2 ^/ w9 |0 a: K3 Q+ W3 T% n6 X

38.  当类成员包括委托的时候) P! D  ^: X) z/ P% E

a)  Copy a delegate to a local variable before publishing to avoid concurrency race

condition.

b)  在调用委托之前一定要检查它是否为null0 r# u# J% z' d3 Z3 l

public class MySource 5 g" ]( N% ^2 [

{ 3 N2 L0 \( [! a8 Z' {' y: c

public event EventHandler  MyEvent;
" L' O. C! _- M
public void FireEvent() 0 d! T9 D' V" l

{ 6 E6 H" W( |- s; C3 ~, R4 W

   EventHandler temp = MyEvent; # p. }: o7 k- F2 S9 W6 [

   if(temp != null ) 7 }) [# q0 e; z
) W( r. Y. [" p
   { 1 O& R$ h4 ?$ M$ S% W) \8 k

      temp(this,EventArgs.Empty);
, |4 \" S1 j4 n
   } ) q6 y1 N0 u6 z4 ?5 r
- ?$ m) p) {1 T
} ' ?7 A- Y! n! R# O4 x0 l

}

39.  不要提供公共的事件成员变量，使用事件访问器替换这些变量。

public class MySource % l/ R& _) i  I: L; W. B$ L

{ : B" P- q" z- F3 D1 S
% Q2 E: c" l: R( f( e
MyDelegate m_SomeEvent ; 3 \, F6 D( T% z$ O8 l

public event MyDelegate SomeEvent & `+ O3 T" Q" a

{

   add ; M4 S* a7 G2 Y
! w( i8 a- y! k$ b% ~
   { ) ^! k2 y7 T) {: ^: q) _3 p

      m_SomeEvent += value;
2 H2 [: c1 x3 t( x  s8 @. l, a
   }
( u7 }# Z/ ~& p. a3 }, X0 `8 Q
   remove
4 q9 g; ^7 p/ S8 S: V
   { % w4 j) W+ S" ~) L5 ]
# n/ k& t5 E* l9 X, |8 w7 n
      m_SomeEvent -= value;
- a0 `! d+ {; v% ]
   }
* s* V8 L' P* R
}

}
9 p. h$ G# F0 D8 P
40.  使用一个事件帮助类来公布事件的定义。 " L0 T# R9 A% d5 c4 A

41.  总是使用接口。; F  y' @+ l6 z

42.  类和接口中的方法和属性至少为2:1的比例。0 v$ [1 w! m* d' G( c  z
" z* I5 q2 T! t) j
43.  避免一个接口中只有一个成员。9 h: I6 R4 i. A5 m

44.  尽量使每个接口中包含3－5个成员。

45.  接口中的成员不应该超过20个。! R7 q* l4 |+ m6 E1 z

a)  实际情况可能限制为12个

46.  避免接口成员中包含事件。$ C& d3 ]( $ r& v& N; s8 Q3 T
( D* I) \* ^( E- o5 y/ t' H
47.  避免使用抽象方法而使用接口替换。
8 B) S% h, c6 E0 _
48.  在类层次中显示接口。

49.  推荐使用显式的接口实现。

50.  从不假设一个类型兼容一个接口。Defensively query for that interface.
- B- Y# P/ ~! Q" B( k( @  u
SomeType obj1; 1 h! k1 r- l! ]7 K: v3 ]

IMyInterface obj2; 9 P; Y6 \1 E$ l# $ t5 \9 z



/* 假设已有代码初始化过obj1，接下来 */ * a7 k# D0 I) U/ [
4 a9 Z" s! _( b$ W. }: Q' z
obj2 = obj1 as IMyInterface;

if (obj2 != null)
6 T3 {; n: S5 `
{
' @( V4 e2 X5 X2 e0 X& ?, z$ r: m+ u
obj2.Method1();

} * M0 n2 h" F- U; w

else / L7 b( n" }+ u# P1 y" O$ x2 y3 [

{ ; e/ G( T7 C+ {

//处理错误

}
7 a6 I+ x- G1 |8 G& M9 W, t
51.  表现给最终用户的字符串不要使用硬编码而要使用资源文件替换之。

52.  不要硬编码可能更改的基于配置的字符串，比如连接字符串。
& y2 B2 e- w1 F8 c( L  `
53.  当需要构建长的字符串的时候，使用StringBuilder不要使用string% O) ?7 W, \5 K

54.  避免在结构里面提供方法。
: O- V0 B0 ~1 R4 e$ V/ E  H
a)  建议使用参数化构造函数, S' C0 v1 R+ J! b, L

b)  可以重裁操作符/ D- D& t8 z3 U" @! d! u1 ?2 c
9 N) ]" N: M2 k* _: j9 K0 C, G2 K
55.  总是要给静态变量提供静态构造函数。

56.  能使用早期绑定就不要使用后期绑定。. o0 k+ @5 h( ]9 r  h* A
0 t; r: P8 {. w& I( j) U) r6 A% w
57.  使用应用程序的日志和跟踪。! v, t7 o. `7 ~9 n

58.  除非在不完全的switch语句中否则不要使用goto语句。

59.  在switch语句中总是要有default子句来显示信息(Assert)。% G4 m) X0 O5 l# ?

int number  = SomeMethod();
( f- \- K& v2 ~( F
switch(number)

{

case 1: - N( J- ]% `2 o2 X1 k

   Trace.WriteLine("Case 1:");

   break; + G3 g7 H) X4 @$ \

case 2: ' g1 v9 }4 \' k2 Z
% }0 B2 H' o. T8 v9 c& ]
   Trace.WriteLine("Case 2:");
6 @) K/ r; E  H+ r3 |
   break;

default :   U7 C  z8 }# X: R
# p; `& ]% G$ f; |- \) }
   Debug.Assert(false); " q8 R, e. j% n8 Z7 i8 M# x

   break;
6 B0 C, c8 {8 ~- E# j+ s' _' Y
}
/ m! `. S% O1 @& b4 ?
60.  除非在构造函数中调用其他构造函数否则不要使用this指针。9 Z2 I9 K/ N+ c5 J% Y

// 正确使用this的例子

public class MyClass 2 V+ D$ [% v' M+ Y8 g5 G7 F

{ 8 s- L# _  b1 ~9 F+ M) V3 h( `3 G

public MyClass(string message )
2 K7 `8 [% R6 D/ G$ Y! v
{}

public MyClass()  : this("hello")

{} 5 d6 a/ b( ~$ y+ N- Z* x6 Q# u; i

}

61.  除非你想重写子类中存在名称冲突的成员或者调用基类的构造函数否则不要使用base来访问基类的成员。4 g( T7 f) Z! N0 s
2 B; u1 R% k6 o; v/ C! P) J* q; @
// 正确使用base的例子

public class Dog
0 b/ G6 x% y9 {- z  `. G) x
{ - a) q3 b' K+ Z/ y2 R1 M
$ ?' t6 ^( D+ e: q, p
public Dog(string name) ' S2 b- l4 F. f: `* c: q- d* r
6 O2 `$ @( c$ |8 P5 H; S9 a" T4 L
{}
& o; \/ q+ v1 K
virtual public void Bark( int howLong) 7 W5 x: Y$ d8 D  _) v% S' D

{}
, e+ Y, [" u0 w; B/ x0 S
} 7 C. z  j1 `9 A2 D1 I9 k" h' H

public class GermanShepherd : Dog $ ~$ G7 f5 E9 a) ?0 B
0 _9 d; D# B0 j* ]
{ / L6 T; X& `/ `+ t2 d
/ Q3 O; D+ i' ^5 u* [5 h
public GermanShe pherd(string name): base (name) % h+ K! \6 x0 k% h$ l& f2 j
/ g# Z2 [( I) Z8 q2 p/ W
{} , |5 J1 t) Q( ~( n

override public void Bark(int  howLong)
# o" j" M% a% M+ J5 k, _7 R
{

   base .Bark(howLong);
  h. S) a/ _9 v  g
}
) f( J! l- v6 u: e2 F; f
} 2 Y5 ~: O7 ^1 X8 a) G
( _7 k4 O+ [) Q  q$ S7 z# f
62.  基于模板的时候要实现Dispose()和Finalize()两个方法。

63.  通常情况下避免有从System.Object转换来和由System.Object转换去的代码，而使用强制转换或者as操作符替换。/ U) B! Z5 @8 Z* D( j* k8 o. {1 t
& \; B3 |, n  o% z4 h$ p# M& Q. G
class SomeClass 1 @1 \! ^* K; ?, G. m
, }& d0 |& f; {3 v
{} 2 p' b& b, p9 L( [5 b" h0 Z" @

//避免： & P( u: C: P. x3 f$ [9 ^

class MyClass<T>  + M% U' K2 _7 x1 m% w' \) e. T
& c1 t7 ?/ h9 m5 b) S1 h! X
{ " S& M; `1 p* v7 Q$ C* y+ ~
' M% x3 k3 @5 m4 K
void SomeMethod(T t) + y: u' c1 B: H

{ ! c% I- ]$ P7 Y; J* k

   object temp = t;
; |/ T( l! I- i- ]
   SomeClass obj = (SomeClass)temp;

} 9 K* Z" C, f0 e% V8 N/ p7 l
1 b0 ^4 v0 w7 K, }5 y
} 2 }' T( e3 v! @6 k6 E+ e
! N2 [* v0 k. j5 u1 D* D% i
// 正确： & A/ c: i6 \* g3 f

class MyClass<T> where T : SomeClass - `) Q+ X7 U7 @  G
+ w$ k1 C1 L) J7 k* A: A
{
- l# }: l. T1 y0 D0 l& U
void SomeMethod(T t) . U  z" F( d1 Z  I, i

{

   SomeClass obj = t; " Z5 h7 a7 J' R# q) f$ F
& Q' f1 @+ E2 _7 s$ \% C
}

}
, \$ B+ H6 ~2 k( ^# u
64.  在一般情况下不要定影有限制符的接口。接口的限制级别通常可以用强类型来替换之。, k/ B  ]" v' w  H  d
public class Customer 8 \5 i0 @$ p6 k2 e4 k

{…}

//避免：4 d7 ?0 i  g4 B, d; z
; v" a# W5 L% t+ o! J2 o
public interface IList<T> where T : Customer

{…} - j6 T" X  |7 b, D+ u2 e
4 J& Y+ H1 M% W2 d. R& D
//正确：

public interface ICustomerList : IList<Customer>

{…} 6 b& l& `8 f1 z1 m

65.  不确定在接口内的具体方法的限制条件。2 T! p9 Z* {' r

66.  总是选择使用C#内置（一般的generics）的数据结构。