原因

跨站脚本Cross-Site Scripting（XSS）又叫CSS (Cross Site Script) ，跨站脚本攻击。它指的是恶意攻击者往Web页面里插入恶意html代码，当用户浏览该页之时，嵌入其中Web里面的html代码会被执行，从而达到恶意 用户的特殊目的。XSS属于被动式的攻击，因为其被动且不好利用，所以许多人常呼略其危害性。
跨站脚本Cross-Site Scripting（XSS）是最为流行的Web安全漏洞之一。据统计，2007年，跨站脚本类的安全漏洞的数目已经远远超出传统类型的安全漏洞(http://en.wikipedia.org/wiki/Cross-site_scripting)

虽然在IE8中引入了客户端的XSS过滤器以减少XSS对用户造成的危害，但是XSS本质上是Web应用服务的漏洞，仅仅依赖客户端的保护措施是不够的。解决问题的根本是在Web应用程序的代码中消除XSS安全漏洞。

以下是在Web应用的开发中避免XSS安全漏洞的几个原则：

• 检查所有产生动态网页的代码
• 判定动态网页的内容是否包括不安全的输入信息
• 对输入进行校验
• 对输出进行编码以过滤特殊字符

采用不同的Web开发工具，实施以上原则的具体步骤也不相同。当需要将一个字符串输出到Web网页时，但又不能完全确定这个字符串是否包括HTML 的特殊字符，例如“<,>,&”等等，可以使用编码（HTMLEncode）以过滤这些特殊字符。在ASP.NET中有两种方法：一 种是使用HttpUtility，另一种就是使用微软提供的XSS库，最新版本是3.0 ,采用MS-PL协议发布的开源项目，7月14日发布了，下载地址是：http://www.microsoft.com/downloads/details.aspx?FamilyId=051ee83c-5ccf-48ed-8463-02f56a6bfc09&displaylang=en。

AntiXss的使用方式与HttpUtility类似：

String Name = AntiXss.HtmlEncode(Request.QueryString["Name"]);

它们最大的区别在于HttpUtility.HtmlEncode采用的是黑名单验证（Black list）方式。即HttpUtility.HtmlEncode仅仅过滤它知道的特殊字符，而允许其它的输入。AntiXss.HtmlEncode采 用的白名单验证（White list）方式。它只允许输出它认为合法的字符，而过滤掉其它的所有字符。

两者中，AntiXss.HtmlEncode要更为安全，是推荐的使用手段。

在asp.net 程序中避免 Cross-Site Scripting 攻击的正确方法：

(1) ValidateRequest = true

(2) 对于所有使用者的输入加以 编码 并检查长度 ： Application、Session、Url QueryString、Cookie、HTTP Header、数据库、文件、Form表单(根据输出的区域，使用以下相对应的七种编码方法)

XSS Libray 包含如下的方法：

具体的使用方法及示例，请参考MSDN： Microsoft Anti-Cross Site Scripting Library V1.5: Protecting the Contoso Bookmark Page 

AntiXSS Library v3.0 除了保留了老版本的一些静态的Encode工具方法(重新实现),另外最重要的就是新增了
AntiXSS HttpModule 用于统一 Encode 输出ASP.Net Server Web Control 为encode 输出的相关属性,如:Text属性等
原理大概是《利用 HttpModule,基于输出,统一控制、干预、处理(例如: 过滤关键字、AntiXSS) ASP.Net WebForm Control 展现属性的方案原型》
http://www.cnblogs.com/Microshaoft/archive/2009/01/08/1371475.html

微软反跨站脚本库主页：http://msdn.microsoft.com/en-us/security/aa973814.aspx
XSS（跨站）攻击全解析: http://www4.it168.com/jtzt/shenlan/safe/xss/
CodePlex站点: http://antixss.codeplex.com/

基本使用方式

　 　反射是.NET中非常重要的功能。使用反射来构造对象、调用方法或是访问属性是某些项目中常用的做法之一（例如ORM框架）。众所周知，与一个成员的直 接访问相比，反射调用的性能要低好几个数量级。FastReflectionLib提供了一种简便的方式，使一些常用反射调用的性能得到大幅提高。如下：

using System;
using System.Reflection;
using FastReflectionLib;

namespace SimpleConsole
{
class Program
{
static void Main(string[] args)
        {
PropertyInfo propertyInfo = typeof(string).GetProperty("Length");
MethodInfo methodInfo = typeof(string).GetMethod("Contains");

string s = "Hello World!";

// get value by normal reflection
int length1 = (int)propertyInfo.GetValue(s, null);
// get value by the extension method from FastReflectionLib,
            // which is much faster
int length2 = (int)propertyInfo.FastGetValue(s);

// invoke by normal reflection
bool result1 = (bool)methodInfo.Invoke(s, new object[] { "Hello" });
// invoke by the extension method from FastReflectionLib,
            // which is much faster
bool result2 = (bool)methodInfo.FastInvoke(s, new object[] { "Hello" });
        }
    }
}

　　在得到了PropertyInfo或MethodInfo对象之后，我们可以使用GetValue或Invoke方法来访问属性或调用方法。在 FastReflectionLib中为PropertyInfo、MethodInfo等对象定义了对应的扩展方法，于是我们就可以使用这些扩展方法 （从代码上看来，基本上只是在原来的方法之前加上“Fast”）来进行调用，与之前的方法相比，新的扩展方法性能有极大的提高。

直接使用各工作对象

　　各FastXxx方法实际上是将PropertyInfo等对象作为Key去一个Cache中获取对应的工作对象，然后调用工作对象上对应的方法。因此，直接调用工作对象可以获得更好的性能。各工作对象类型的对应关系如下：

• PropertyInfo：IPropertyAccessor
• MethodInfo：IMethodInvoker
• ConstructorInfo：IConstructorInvoker
• FieldInfo：IFieldAccessor

　　我们可以使用FastReflectionCaches.MethodInvokerCache来获取一个IMethodInvoker对象：

static void Execute(MethodInfo methodInfo, object instance, int times)
{ 
IMethodInvoker invoker = FastReflectionCaches.MethodInvokerCache.Get(methodInfo);
object[] parameters = new object[0];
for (int i = 0; i < times; i++)
    {
        invoker.Invoke(instance, parameters);
    }
}

工作对象的默认实现与扩展

　　在FastReflectionLib中，已经提供了IPropertyAccessor等接口的默认实现。该实现将会构造一颗表达式树 （Expression Tree）并将其编译（调用其Compile方法）以获得一个与反射方法签名相同的委托对象。这是一种简单、通用而安全的实现，由于Compile方法使 用了Emit，其性能也较为令人满意（可见下面的性能测试）。但是这并不是性能最高的做法，如果使用Emit生成最优化的代码，其性能甚至会高于方法的直 接调用（例如Dynamic Reflection Library）。如果您想使用更好的实现来替换，则可以自行构造一个工作对象接口的实现，并替换对应的Factory：

public class BetterPropertyAccessor : IPropertyAccessor
{
public BetterPropertyAccessor(PropertyInfo propertyInfo) { ... }

    ...
}

public class BetterPropertyAccessorFactory :
IFastReflectionFactory<PropertyInfo, IPropertyAccessor>
{
public IPropertyAccessor Create(PropertyInfo key)
    {
return new BetterPropertyAccessor(key);
    }
}

class Program
{
static void Main(string[] args)
    {
FastReflectionFactories.PropertyAccessorFactory =
new BetterPropertyAccessorFactory();

        ...
    }
}

缓存的默认实现与扩展

　　在FastReflectionLib中使用基于 System.Collections.Generic.Dictionary<TKey, TValue>类型编写的缓存容器。每次调用FastXxx扩展方法时，类库将从对应的缓存容器中获取工作对象。如果缓存容器中还没有所需的工作对 象，那么它就会调用合适的Factory来构造新的工作对象。从下面的性能测试来看，许多时间是消耗在缓存查找上的，如果您有更好的缓存实现，可以使用以 下的方法替换默认的缓存的容器：

public class BetterMethodInvokerCache :
IFastReflectionCache<MethodInfo, IMethodInvoker>
{
public IMethodInvoker Get(MethodInfo key) { ... }
}

class Program
{
static void Main(string[] args)
    {
FastReflectionCaches.MethodInvokerCache = 
new BetterMethodInvokerCache();

        ...
    }
}

根据需要自行缓存工作对象

　　FastReflectionLib中通过PropertyInfo等对象作为Key，对PropertyAccessor等工作对象进行缓 存。但是在某些场景下，您也可以选择合适的方式来自行缓存工作对象。与FastReflectionLib源码同时发布的CustomCache示例网站 中包含了一个FastEval扩展，在某些场景下，我们可以使用这个更高效的方法来替换内置的Eval方法。这个示例的特点如下：

• 使用对象的类型和属性名同时作为缓存的Key获取对应的PropertyAccessor对象
• 使用PropertyAccessor获取“匿名对象”中的属性值
• 缓存的作用域为特定页面，而不是整个AppDomain。

性能测试

　　FastReflectionLib源码中包含了一个性能测试项目，您可以从中看出FastReflectionLib对于反射的性能改进。摘录部分数据如下（测试在我的笔记本上运行，Release编译）。

　　执行以下方法：

public class Test
{
public void MethodWithArgs(int a1, string a2) { }
}

　　进行一百万次调用，结果如下：

这样每次context.Response.Write出支的数据就压缩了

对效多的文本信息压缩可以压缩到原来三分之一到四分之一的样子

如果发送的信息只有几个字节就没有必要了

让浏览器做缓存需要给浏览器发送指定的Http头，告诉浏览器缓存多长时间，或者坚决不要缓存。作为.net的程序员，其实我们一直都在用这种方法，在OutputCache指令中指定缓存的Location为Client时，其实就是给浏览器发送了一个Http头，告诉浏览器这个Url要缓存多长时间，最后修改的时间。

微软在OutputCacheModule中对这些缓存用到的Http头给我们进行了很好的封装，但是了解这些Http头可以更灵活的使用它们。

和客户端缓存相关的Http头有以下几个，分别是：
1. Expires:+过期时间
表示在指定时间后浏览器缓存失效，需要注意的是这儿的过期时间必须是HTTP格式的日期时间，其他的都会被解析成当前时间“之前”，缓存会马上过期，HTTP的日期时间必须是格林威治时间（GMT），而不是本地时间。举例：
Expires: Fri, 30 Oct 2009 14:19:41

使用Expires过期必须要求服务器的时间是正确的，否则发送的http头就会出问题，在windows服务下可以设置时间服务器来同步时间
2. Cache-control:
Cache-control直译成中文就是缓存控制，它的作用就是缓存控制，这个http头的值有几种。
1) max-age=[秒] — 执行缓存被认为是最新的最长时间。类似于过期时间，这个参数是基于请求时间的相对时间间隔，而不是绝对过期时间，[秒]是一个数字，单位是秒：从请求时间开始到过期时间之间的秒数。
2) s-maxage=[秒] — 类似于max-age属性，除了他应用于共享（如：代理服务器）缓存
3) public — 标记认证内容也可以被缓存，一般来说： 经过HTTP认证才能访问的内容，输出是自动不可以缓存的；
4) no-cache — 强制每次请求直接发送给源服务器，而不经过本地缓存版本的校验。这对于需要确认认证应用很有用（可以和public结合使用），或者严格要求使用最新数据的应用（不惜牺牲使用缓存的所有好处）；
5) no-store — 强制缓存在任何情况下都不要保留任何副本
6) must-revalidate — 告诉缓存必须遵循所有你给予副本的新鲜度的，HTTP允许缓存在某些特定情况下返回过期数据，指定了这个属性，你高速缓存，你希望严格的遵循你的规则。
7) proxy-revalidate — 和 must-revalidate类似，除了他只对缓存代理服务器起作用
举例:
Cache-Control: max-age=3600, must-revalidate

很显然Cache-control可以提供比Expires更灵活的缓存控制，而且它不需要依赖于服务器时间。
在Asp.Net中微软把对Cache-control属性的设置封装到了HttpCachePolicy类中，我们可以通过Response.Cache来调用以下方法来做到对Cache-Control Http头值的控制：
Response.CacheControl;
Response.Cache.SetNoStore
Response.Cache.SetMaxAge
Response.Cache.SetProxyMaxAge
Response.Cache.SetRevalidation
           
3. Last-Modified/If-Modified-Since
这两个Http头是一对，前者表示某个地址的最近更新时间，是服务器端响应给客户端的；而后者是客户端浏览器发送给服务器的，告诉web服务器客户端有一个最后更改时间为什么时间的缓存，服务器端接收到If-Modified-Since头后则判断客户端缓存的这份url地址的缓存是否是最新的，如果是最新的则服务器端直接给客户端返回HttpStatus 304，意思是说这个内容在你上次请求之后没有变化过，你直接用缓存就可以了；如果服务器发现url的最后更新时间比If-Modified-Since 的值要新，则会输出新的内容。

同样微软也为我们做了服务器端设置的封装，我们可以这样调用
Response.Cache.SetLastModified(DateTime)
Response.Cache.SetLastModifiedFromFileDependencies()

如果有更复杂的需求就需要自己处理了。

4. ETag/If-None-Match
ETag和Last-Modified类似，不过他发送的是一个字符串来标示url的版本，如果url变了则此标示也跟着变化，在浏览器发送If-None-Match时告诉浏览器内容已经变了，或者没变可以使用缓存。

Iis会自动给静态文件加上Etag，在文件发生改变时重新生成一个Etag，这样对于一个网站中的n多个静态文件如：样式表，小图片等，客户端只下载一次就够了，可以减轻负载。

在Asp.Net中我们可以用以下两个方法来设置
Response.Cache.SetETag(string)
Response.Cache.SetETagFromFileDependencies()

尽管微软为我们做了很多封装，但是我们还是需要详细的了解之后才可以用好这几个Http头。

///<summary>
///得到随机字符.
///</summary>
///<param name="intLength">Length of the int.</param>
///<param name="booNumber">if set to <c>true</c> [boo number].</param>
///<param name="booSign">if set to <c>true</c> [boo sign].</param>
///<param name="booSmallword">if set to <c>true</c> [boo smallword].</param>
///<param name="booBigword">if set to <c>true</c> [boo bigword].</param>
///<returns></returns>
public string getRandomizer(int intLength, bool booNumber, bool booSign, bool booSmallword, bool booBigword)
{
 //定义
 Random ranA = new Random();
 int intResultRound = 0;
 int intA = 0;
 string strB = "";
 while (intResultRound < intLength)
 {
  //生成随机数A，表示生成类型
  //1=数字，2=符号，3=小写字母，4=大写字母
  intA = ranA.Next(1, 5);
  //如果随机数A=1，则运行生成数字
  //生成随机数A，范围在0-10
  //把随机数A，转成字符
  //生成完，位数+1，字符串累加，结束本次循环
  if (intA == 1 && booNumber)
  {
   intA = ranA.Next(0, 10);
   strB = intA.ToString() + strB;
   intResultRound = intResultRound + 1;
   continue;
  }
  //如果随机数A=2，则运行生成符号
  //生成随机数A，表示生成值域
  //1：33-47值域，2：58-64值域，3：91-96值域，4：123-126值域
  if (intA == 2 && booSign == true)
  {
   intA = ranA.Next(1, 5);
   //如果A=1
   //生成随机数A，33-47的Ascii码
   //把随机数A，转成字符
   //生成完，位数+1，字符串累加，结束本次循环
   if (intA == 1)
   {
    intA = ranA.Next(33, 48);
    strB = ((char)intA).ToString() + strB;
    intResultRound = intResultRound + 1;
    continue;
   }

   //如果A=2
   //生成随机数A，58-64的Ascii码
   //把随机数A，转成字符
   //生成完，位数+1，字符串累加，结束本次循环
   if (intA == 2)
   {
    intA = ranA.Next(58, 65);
    strB = ((char)intA).ToString() + strB;
    intResultRound = intResultRound + 1;
    continue;
   }

   //如果A=3
   //生成随机数A，91-96的Ascii码
   //把随机数A，转成字符
   //生成完，位数+1，字符串累加，结束本次循环
   if (intA == 3)
   {
    intA = ranA.Next(91, 97);
    strB = ((char)intA).ToString() + strB;
    intResultRound = intResultRound + 1;
    continue;
   }

   //如果A=4
   //生成随机数A，123-126的Ascii码
   //把随机数A，转成字符
   //生成完，位数+1，字符串累加，结束本次循环
   if (intA == 4)
   {
    intA = ranA.Next(123, 127);
    strB = ((char)intA).ToString() + strB;
    intResultRound = intResultRound + 1;
    continue;
   }
  }

  //如果随机数A=3，则运行生成小写字母
  //生成随机数A，范围在97-122
  //把随机数A，转成字符
  //生成完，位数+1，字符串累加，结束本次循环
  if (intA == 3 && booSmallword == true)
  {
   intA = ranA.Next(97, 123);
   strB = ((char)intA).ToString() + strB;
   intResultRound = intResultRound + 1;
   continue;
  }

  //如果随机数A=4，则运行生成大写字母
  //生成随机数A，范围在65-90
  //把随机数A，转成字符
  //生成完，位数+1，字符串累加，结束本次循环
  if (intA == 4 && booBigword == true)
  {
   intA = ranA.Next(65, 89);
   strB = ((char)intA).ToString() + strB;
   intResultRound = intResultRound + 1;
   continue;
  }
 }
 return strB;
}

//随机字符串生成器的主要功能如下：
//1、支持自定义字符串长度
//2、支持自定义是否包含数字
//3、支持自定义是否包含小写字母
//4、支持自定义是否包含大写字母
//5、支持自定义是否包含特殊符号
//6、支持自定义字符集

///<summary>
///生成随机字符串
///</summary>
///<param name="length">目标字符串的长度</param>
///<param name="useNum">是否包含数字，1=包含，默认为包含</param>
///<param name="useLow">是否包含小写字母，1=包含，默认为包含</param>
///<param name="useUpp">是否包含大写字母，1=包含，默认为包含</param>
///<param name="useSpe">是否包含特殊字符，1=包含，默认为不包含</param>
///<param name="custom">要包含的自定义字符，直接输入要包含的字符列表</param>
///<returns>指定长度的随机字符串</returns>
public string GetRnd(int length, bool useNum, bool useLow, bool useUpp, bool useSpe, string custom)
{
 byte[] b = new byte[4];
 new System.Security.Cryptography.RNGCryptoServiceProvider().GetBytes(b);
 Random r = new Random(BitConverter.ToInt32(b, 0));
 string s = null, str = custom;
 if (useNum == true) { str += "0123456789"; }
 if (useLow == true) { str += "abcdefghijklmnopqrstuvwxyz"; }
 if (useUpp == true) { str += "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; }
 if (useSpe == true) { str += "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~"; }
 for (int i = 0; i < length; i++)
 {
  s += str.Substring(r.Next(0, str.Length - 1), 1);
 }
 return s;
}