asp.net性能优化的几个方面

c#（或vb.net）程序改进 
1、使用值类型的ToString方法 

在连接字符串时，经常使用"+"号直接将数字添加到字符串中。这种方法虽然简单，也可以得到正确结果，但是由于涉及到不同的数据类型，数字需要通过装箱操作转化为引用类型才可以添加到字符串中。但是装箱操作对性能影响较大，因为在进行这类处理时，将在托管堆中分配一个新的对象，原有的值复制到新创建的对象中。 

使用值类型的ToString方法可以避免装箱操作，从而提高应用程序性能。 
int num=1; 
string str="go"+num.ToString(); 

2、运用StringBuilder类 

String类对象是不可改变的，对于String对象的重新赋值在本质上是重新创建了一个String对象并将新值赋予该对象，其方法ToString对性能的提高并非很显著。 

在处理字符串时，最好使用StringBuilder类，其.NET 命名空间是System.Text。该类并非创建新的对象，而是通过Append，Remove，Insert等方法直接对字符串进行操作，通过ToString方法返回操作结果。 

其定义及操作语句如下所示： 
int num; 
System.Text.StringBuilder str = new System.Text.StringBuilder(); //创建字符串 
str.Append(num.ToString()); //添加数值num 
Response.Write(str.ToString); //显示操作结果 

3、使用 HttpServerUtility.Transfer 方法在同一应用程序的页面间重定向 
采用 Server.Transfer 语法，在页面中使用该方法可避免不必要的客户端重定向（Response.Redirect）。 

4、避免使用ArrayList。 
因为任何对象添加到ArrayList都要封箱为System.Object类型，从ArrayList取出数据时，要拆箱回实际的类型。建议使用自定义的集合类型代替ArrayList。asp.net 2.0提供了一个新的类型，叫泛型，这是一个强类型，使用泛型集合就可以避免了封箱和拆箱的发生，提高了性能。 
5、使用HashTale代替其他字典集合类型 
（如StringDictionary,NameValueCollection,HybridCollection），存放少量数据的时候可以使用HashTable. 
6、为字符串容器声明常量，不要直接把字符封装在双引号" "里面。 
//避免 
MyObject obj = new MyObject(); 
obj.Status = "ACTIVE"; 
//推荐 
const string C_STATUS = "ACTIVE"; 
MyObject obj = new MyObject(); 
obj.Status = C_STATUS; 
7、不要用ToUpper(),ToLower()转换字符串进行比较，用String.Compare代替，它可以忽略大小写进行比较. 
例： 
const string C_VALUE = "COMPARE"; 
if (String.Compare(sVariable, C_VALUE, true) == 0) 
{ 
Console.Write( "相同"); 
} 
也可以用str == String.Empty或者str.Length == 0判断是否为空。(注意判断输入数据的长度，可防止sql注入式攻击) 
将String对象的Length属性与0比较是最快的方法，避免不必要的调用 ToUpper 或 ToLower 方法。 
8、类型转化Int32.TryParse()优于Int32.Parse()优于Convert.ToInt32()。 
建议.NET1.1下用Int32.Parse()；.NET2.0用Int32.TryParse()。 
因为： 
Convert.ToInt32 会把最终的解析工作代理给 Int32.Parse； 
Int32.Parse 会把最终的解析工作代理给Number.ParseInt32； 
Int32.TryParse 会把最终的解析工作代理给Number.TryParseInt32。 
9、如果只是从XML对象读取数据，用只读的XPathDocument代替XMLDocument,可以提高性能 
//避免 
XmlDocument xmld = new XmlDocument(); 
xmld.LoadXml(sXML); 
txtName.Text = xmld.SelectSingleNode( "/packet/child").InnerText; 
//推荐 
XPathDocument xmldContext = new XPathDocument(new StringReader(oContext.Value)); 
XPathNavigator xnav = xmldContext.CreateNavigator(); 
XPathNodeIterator xpNodeIter = xnav.Select( "packet/child"); 
iCount = xpNodeIter.Count; 
xpNodeIter = xnav.SelectDescendants(XPathNodeType.Element, false); 
while(xpNodeIter.MoveNext()) 
{ 
sCurrValues += xpNodeIter.Current.Value+ ","; 
} 

10、避免在循环体里声明变量，应该在循环体外声明变量，在循环体里初始化。 

C#程序开发要遵循的一个基本原则就是避免不必要的对象创建 

//避免 
for(int i=0; i <10; i++) 
{ 
SomeClass objSC = new SomeClass(); 
} 
//推荐 
SomeClass objSC = null; 
for(int i=0; i <10; i++) 
{ 
objSC = new SomeClass(); 
} 
11、捕获指定的异常，不要使用通用的System.Exception. 
//避免 
try 
{ 
<some logic> 
} 
catch(Exception exc) 
{ 
<Error handling> 
} 

//推荐 
try 
{ 
<some logic> 
} 
catch(System.NullReferenceException exc) 
{ 
<Error handling> 
} 
catch(System.ArgumentOutOfRangeException exc) 
{ 
<Error handling> 
} 
catch(System.InvalidCastException exc) 
{ 
<Error handling> 
} 
12、使用Try...catch...finally时， 要在finally里释放占用的资源如连接，文件流等 
不然在Catch到错误后占用的资源不能释放。 

try 
{} 
catch 
{} 
finally 
{ 
conntion.close(); 
} 

13、不要用Exception控制程序流程 
有些程序员可能会使用异常来实现一些流程控制。例如： 
try{ 
result=100/num; 
} 
Catch(Exception e) 
{ 
result=0; 
} 
但实际上，Exception是非常消耗系统性能的。除非必要，不应当使用异常控制来实现程序流程。上面的代码应当写为： 
if(num!=0) 
result=100/num; 
else 
result=0; 

14、避免使用递归调用和嵌套循环，使用他们会严重影响性能，在不得不用的时候才使用。 

------------------------------------------------------------

StringJoiner 拯救那些性能低下的字符串拼装代码

 

StringJoiner

很简单，把 string s 改成 StringJoiner s 就大功告成。即

StringJoiner s = string.Empty;
s += "Bruce";
s += "Who?";
s += "a guy think sth different...";

 

咋这么简单就提高性能？忽悠我？

当然不是忽悠大家，也不是玩魔术，文章末会有性能测试数据，有图有真相。

现在让我来揭开 StringJoiner 的面纱，最后你肯定会说：原来这么简单。

StringJoiner 其实是类似装饰者模式，对外隐藏了StringBuilder ，就像魔术师喜欢把一堆道具藏到袖子，以忽悠观众那样。

public class StringJoiner 
{
    protected StringBuilder Builder;

    public StringJoiner()
    {
        Builder = new StringBuilder();
    }
}

（把Builder定义成protected ，期待某天可能需要继承StringJoiner 来继续“忽悠观众”）

StringJoiner 是怎么实现刚才的代码？

1.隐式转换

如：

StringJoiner s = string.Empty;

 

的谜底是：

public static implicit operator StringJoiner(string value)
{
    StringJoiner text = new StringJoiner();
    text.Builder.Append(value);
    return text;
}

（新建一个对象，把赋值转移到 StringBuilder 的Append方法）

 

2. 重载操作符

如：

s += "Bruce";

 

的谜底是：

public static StringJoiner operator +(StringJoiner self, string value)
{
    self.Builder.Append(value);
    return self;
}

（实现 StringJoiner 与 string 类型可以通过运算符“+”操作，同样是把字符串交给StringBuilder 的Append方法）

为了更通用，如实现与其他类型连接：

s += 123;
s += 0.314;
s += 'c';

 

因此，必须重载 StringJoiner + Object

public static StringJoiner operator +(StringJoiner self, object value)
{
    self.Builder.Append(value);
    return self;
}

 

最后，为了让 StringJoiner 的“忽悠”水平更上一层楼，StringJoiner 的对象必须能够隐式转换成 string 类型：

public static implicit operator string(StringJoiner value)
{
    return value.ToString();
}

public override string ToString()
{
    return this.Builder.ToString();
}

 

当然，到这一刻 StringJoiner 已经足够了，更彻底的“忽悠”并不是本文的目的。 StringJoiner 并不是想替代string，更不是替代StringBuilder，反而我举脚赞成使用StringBuilder。但如果你想重构一段由“string += ” 带来的惨不忍睹的代码时，用StringJoiner 吧。