（备注：这是我使用Reflector查看System.Web和System.Web.Mvc这2个程序集画出来的图，如有错误，欢迎指正。）

图上的内容我就不再解说了，再补充以下几点：

1. IIS是通过“C:\Windows\Microsoft.NET\Framework\v4.0.30319\Config\web.config”配置文件中的<add name=”UrlRoutingModule-4.0″ type=”System.Web.Routing.UrlRoutingModule” />这个配置走到UrlRoutingModule的。
2. MVC中有4种Filter，分别是IActionFilter/IAuthorizationFilter/IExceptionFilter/IResultFilter，这些内容，请听下回分解^_^。
3. MVC框架中非常重要的一部分是Service Location，所有的扩展都是建立在Service Location之上。

前几天看xunit的源码，看到AutoRollbackAttribute这个特性，异常的兴奋 ^_^。怎么就忘了用事务的自动回滚呢？

我们看AutorollbackAttribute的具体实现：

public class AutoRollbackAttribute : BeforeAfterTestAttribute
{
    IsolationLevel isolationLevel = IsolationLevel.Unspecified;
    TransactionScope scope;
    TransactionScopeOption scopeOption = TransactionScopeOption.Required;
    long timeoutInMS = -1;

    /// <summary>
    /// Gets or sets the isolation level of the transaction.
    /// Default value is <see cref="IsolationLevel"/>.Unspecified.
    /// </summary>
    public IsolationLevel IsolationLevel
    {
        get { return isolationLevel; }
        set { isolationLevel = value; }
    }

    /// <summary>
    /// Gets or sets the scope option for the transaction.
    /// Default value is <see cref="TransactionScopeOption"/>.Required.
    /// </summary>
    public TransactionScopeOption ScopeOption
    {
        get { return scopeOption; }
        set { scopeOption = value; }
    }

    /// <summary>
    /// Gets or sets the timeout of the transaction, in milliseconds.
    /// By default, the transaction will not timeout.
    /// </summary>
    public long TimeoutInMS
    {
        get { return timeoutInMS; }
        set { timeoutInMS = value; }
    }

    /// <summary>
    /// Rolls back the transaction.
    /// </summary>
    public override void After(MethodInfo methodUnderTest)
    {
        scope.Dispose();
    }

    /// <summary>
    /// Creates the transaction.
    /// </summary>
    public override void Before(MethodInfo methodUnderTest)
    {
        TransactionOptions options = new TransactionOptions();
        options.IsolationLevel = isolationLevel;
        if (timeoutInMS > 0)
            options.Timeout = new TimeSpan(timeoutInMS * 10);
        scope = new TransactionScope(scopeOption, options);
    }
}

这里使用了.Net Framework自带的TransactionScope。TransactionScope在.NET 2.0中就已经有了，可用于分布式事务。用这种方法来做数据的自动回滚也有一些不足：

1. 数据库要支持事务。
2. 内部数据库操作的逻辑里没有事务的实现。

很庆幸的是我们的项目正好都满足上面的2点，唯一不足的就是mongodb不支持事务。所以就需要混合仓储实现了，事务数据库使用真实的仓储，mongodb使用内存仓储。

项目中是用VS自带的单元测试框架，也不想因为这一个特性而改用xunit，那就只能动手把这个迁移到VS的单元测试框架里了。

/// <summary>
/// 单元测试基类
/// </summary>
[TestClass]
public class BaseUnitTest
{
    IsolationLevel _isolationLevel = IsolationLevel.Unspecified;
    TransactionScopeOption _scopeOption = TransactionScopeOption.Required;
    TransactionScope _transactionScope;
    bool _openAutoRollback = true;

    /// <summary>
    /// 构造函数
    /// </summary>
    /// <param name="autoRollback">是否开启自动回滚，默认开启</param>
    public BaseUnitTest(bool autoRollback = true)
    {
        _openAutoRollback = autoRollback;
    }

    /// <summary>
    /// 自动回滚事务初始化
    /// </summary>
    [TestInitialize]
    public void AutoRollbackBefore()
    {
        if (_openAutoRollback)
        {
            var options = new TransactionOptions();
            options.IsolationLevel = _isolationLevel;
            options.Timeout = new TimeSpan(0, 1, 0);
            _transactionScope = new TransactionScope(_scopeOption, options);
        }
    }

    /// <summary>
    /// 自动回滚事务回滚并释放对象
    /// </summary>
    [TestCleanup]
    public void AutoRollbackAfter()
    {
        if (_openAutoRollback)
        {
            if (_transactionScope == null)
                throw new InvalidOperationException("未初始化TransactionScope");
            //回滚事务
            _transactionScope.Dispose();
            //释放事务对象
            _transactionScope = null;
            //移除所有的缓存
            RemoveHttpRuntimeCache();
        }
    }

    /// <summary>
    /// 移除所有的HttpRuntime缓存
    /// </summary>
    [DebuggerStepThrough]
    private void RemoveHttpRuntimeCache()
    {
        var cache = HttpRuntime.Cache.GetEnumerator();
        var keys = new List<string>();
        while (cache.MoveNext())
        {
            keys.Add(cache.Key.ToString());
        }
        foreach (var key in keys)
        {
            HttpRuntime.Cache.Remove(key);
        }
    }

    /// <summary>
    /// 设置不自动回滚事务
    /// </summary>
    protected void SetAutoRollbackIsUnavailabled()
    {
        _openAutoRollback = false;
    }
}

上面的RemoveHttpRuntimeCache是因为我们在项目中有使用HttpRuntime缓存，关系数据库中的数据回滚后会导致缓存和数据库不一致，所以一但有开启事务的自动回滚，也要相应的清空内存缓存。

方法很简单，跟大家分享一下，和TransactionScope相关的知识，不清楚的同学可以看下MSDN关于“TransactionScope”的文档。

示例是一个雷达图，绘图是在控制器里实现，页面调用只要直接用<img src=”{controller}”>就可以，web.config也不需要再增加任何配置。

主要步骤如下

1、引用2个类库，System.Web.DataVisualization和System.Web.DataVisualization.Design

2、控制器实现代码：

using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Web.Mvc;
using System.Web.UI.DataVisualization.Charting;

namespace MvcChart.Controllers
{
    public class HomeController : Controller
    {
        public ActionResult Index()
        {
            double[] baseValues = { 65.62, 75.54, 60.45, 34.73, 85.42 };
            double[] userValues = { 80.62, 45.54, 80.45, 44.73, 80.42 };
            string[] moduleNames = { "常识判断", "言语理解表达", "判断推理", "数量关系", "资料分析" };
            Chart radar = new Chart();
            radar.Series.Add("baseSeries");
            radar.Series["baseSeries"].Points.DataBindXY(moduleNames, baseValues);
            radar.Series["baseSeries"].ChartType = SeriesChartType.Radar;
            radar.Series["baseSeries"]["RadarDrawingStyle"] = "Area";
            radar.Series["baseSeries"]["AreaDrawingStyle"] = "Polygon";
            radar.Series["baseSeries"]["CircularLabelsStyle"] = "Horizontal";
            radar.Series.Add("userSeries");
            radar.Series["userSeries"].Points.DataBindXY(moduleNames, userValues);
            radar.Series["userSeries"].ChartType = SeriesChartType.Radar;
            radar.Series["userSeries"]["RadarDrawingStyle"] = "Area";
            radar.Series["userSeries"]["AreaDrawingStyle"] = "Polygon";
            radar.Series["userSeries"]["CircularLabelsStyle"] = "Horizontal";
            radar.ChartAreas.Add("chartArea");
            radar.ChartAreas["chartArea"].Area3DStyle.Enable3D = true;
            MemoryStream stream = new MemoryStream();
            radar.SaveImage(stream, ChartImageFormat.Jpeg);
            return new ImageResult(Image.FromStream(stream), ImageFormat.Jpeg);
        }
    }
}

3、注意这里的返回类型，使用的是ImageResult，这是我们自己实现的ActionResult。

using System.Drawing;
using System.Drawing.Imaging;

namespace System.Web.Mvc
{
    public class ImageResult : ActionResult
    {
        public ImageResult()
        { }

        public ImageResult(Image image)
        {
            Image = image;
        }

        public ImageResult(Image image, ImageFormat format)
        {
            Image = image;
            ImageFormat = format;
        }

        /// <summary>
        ///
        /// </summary>
        public Image Image { get; set; }

        /// <summary>
        /// 指定图像的文件格式
        /// </summary>
        public ImageFormat ImageFormat { get; set; }

        public override void ExecuteResult(ControllerContext context)
        {
            if (Image == null)
                throw new ArgumentNullException("Image");

            if (ImageFormat == null)
                throw new ArgumentNullException("ImageFormat");

            context.HttpContext.Response.Clear();

            if (ImageFormat.Equals(ImageFormat.Gif))
                context.HttpContext.Response.ContentType = "image/gif";
            else if (ImageFormat.Equals(ImageFormat.Jpeg))
                context.HttpContext.Response.ContentType = "image/jpeg";
            else if (ImageFormat.Equals(ImageFormat.Png))
                context.HttpContext.Response.ContentType = "image/png";
            else if (ImageFormat.Equals(ImageFormat.Bmp))
                context.HttpContext.Response.ContentType = "image/bmp";
            else if (ImageFormat.Equals(ImageFormat.Tiff))
                context.HttpContext.Response.ContentType = "image/tiff";
            else if (ImageFormat.Equals(ImageFormat.Icon))
                context.HttpContext.Response.ContentType = "image/vnd.microsoft.icon";
            else if (ImageFormat.Equals(ImageFormat.Wmf))
                context.HttpContext.Response.ContentType = "image/wmf";

            Image.Save(context.HttpContext.Response.OutputStream, ImageFormat);
        }
    }
}

非常简单，不需要其它的配置。

多线程并发测试时，需要等所有线程测试结束后通知主线程，主线程才能进行下一步动作，这里主要用到了ManualResetEvent。ManualResetEvent 类表示一个本地等待处理事件，在已发事件信号后必须手动重置该事件。通常，此通信涉及一个线程在其他线程进行之前必须完成的任务。当一个线程开始一个活动（此活动必须完成后，其他线程才能开始）时，它调用 Reset 以将 ManualResetEvent 置于非终止状态。此线程可被视为控制 ManualResetEvent。调用 ManualResetEvent 上的 WaitOne 的线程将阻止，并等待信号。当控制线程完成活动时，它调用 Set 以发出等待线程可以继续进行的信号。并释放所有等待线程。一旦它被终止，ManualResetEvent 将保持终止状态，直到它被手动重置。即对 WaitOne 的调用将立即返回。可以通过将布尔值传递给构造函数来控制 ManualResetEvent 的初始状态，如果初始状态处于终止状态，为 true；否则为 false。

多线程并发测试由以下步骤完成：

1. 创建并发测试的线程数，先创建的线程等待最后一个线程创建完成。
2. 所有线程执行待测试的方法，返回测试的结果。
3. 等所有线程执行完成后，进入思考时间等待。
4. 继续进行循环测试。

我们来看这个多线程并发测试的代码。

    using System;
    using System.Collections.Generic;
    using System.Diagnostics;
    using System.Threading;
    /// <summary>
    /// 并发测试
    /// </summary>
    public class ConcurrentTest : IDisposable
    {
        #region 私有方法
        /// <summary>
        /// 测试方法所在的接口
        /// </summary>
        private Func<bool> func;
        /// <summary>
        /// 主线程控制信号
        /// </summary>
        private ManualResetEvent manualResetEvent;
        /// <summary>
        /// 测试线程控制信号
        /// </summary>
        private ManualResetEvent threadResetEvent;
        /// <summary>
        /// 待执行的线程数
        /// </summary>
        private List<int> threads;
        /// <summary>
        /// 测试结果
        /// </summary>
        private List<ConcurrentTestResult> results;
        /// <summary>
        /// 执行测试的成功数
        /// </summary>
        private int successCount;
        /// <summary>
        /// 执行测试的失败数
        /// </summary>
        private int failureCount;
        /// <summary>
        /// 测试耗时
        /// </summary>
        private long elapsedMilliseconds;
        /// <summary>
        /// 当前线程
        /// </summary>
        private int currentIndex;
        /// <summary>
        /// 当前测试的总线程数
        /// </summary>
        private int currentCount;
        /// <summary>
        /// 思考时间
        /// </summary>
        private int thinkTime;
        /// <summary>
        /// 重复次数
        /// </summary>
        private int repeatCount;
        /// <summary>
        /// 测试计时器
        /// </summary>
        private Stopwatch stopwatch;
        #endregion

        #region 构造函数
        /// <summary>
        /// 构造函数
        /// </summary>
        public ConcurrentTest()
        {
            manualResetEvent = new ManualResetEvent(true);
            threadResetEvent = new ManualResetEvent(true);
            stopwatch = new Stopwatch();
        }
        #endregion

        #region 执行测试
        /// <summary>
        /// 执行多线程测试
        /// </summary>
        /// <param name="threadCount">需要测试的线程数</param>
        /// <param name="func">待执行方法</param>
        /// <returns></returns>
        public List<ConcurrentTestResult> Execute(int threadCount, Func<bool> func)
        {
            return Execute(threadCount, 1, func);
        }
        /// <summary>
        /// 执行多线程测试
        /// </summary>
        /// <param name="threadCount">需要测试的线程数</param>
        /// <param name="repeatCount">重复次数</param>
        /// <param name="func">待执行方法</param>
        /// <returns></returns>
        public List<ConcurrentTestResult> Execute(int threadCount, int repeatCount, Func<bool> func)
        {
            return Execute(threadCount, 0, repeatCount, func);
        }
        /// <summary>
        /// 执行多线程测试
        /// </summary>
        /// <param name="threadCount">需要测试的线程数</param>
        /// <param name="thinkTime">思考时间，单位毫秒</param>
        /// <param name="repeatCount">重复次数</param>
        /// <param name="func">待执行方法</param>
        /// <returns></returns>
        public List<ConcurrentTestResult> Execute(int threadCount, int thinkTime, int repeatCount, Func<bool> func)
        {
            return Execute(new List<int>() { threadCount }, thinkTime, repeatCount, func);
        }
        /// <summary>
        /// 执行多线程测试
        /// </summary>
        /// <param name="threads">分别需要测试的线程数</param>
        /// <param name="thinkTime">思考时间，单位毫秒</param>
        /// <param name="repeatCount">重复次数</param>
        /// <param name="func">待执行方法</param>
        /// <returns></returns>
        public List<ConcurrentTestResult> Execute(List<int> threads, int thinkTime, int repeatCount, Func<bool> func)
        {
            this.func = func;
            this.threads = threads;
            this.thinkTime = thinkTime;
            this.repeatCount = repeatCount;
            CheckParameters();
            CreateMultiThread();
            return this.results;
        }
        #endregion

        #region 验证参数
        /// <summary>
        /// 验证参数
        /// </summary>
        private void CheckParameters()
        {
            if (func == null) throw new ArgumentNullException("func不能为空");
            if (threads == null || threads.Count == 0) throw new ArgumentNullException("threads不能为空或者长度不能为0");
            if (thinkTime < 0) throw new Exception("thinkTime不能小于0");
            if (repeatCount <= 0) throw new Exception("repeatCount不能小于等于0");
        }
        #endregion

        #region 创建多线程并执行测试
        /// <summary>
        /// 创建多线程进行测试
        /// </summary>
        private void CreateMultiThread()
        {
            results = new List<ConcurrentTestResult>(threads.Count);
            foreach (int threadCount in threads)
            {
                for (int repeat = 0; repeat < repeatCount; repeat++)
                {
                    //主线程进入阻止状态
                    manualResetEvent.Reset();
                    //测试线程进入阻止状态
                    threadResetEvent.Reset();
                    stopwatch.Reset();
                    currentCount = threadCount;
                    currentIndex = 0;
                    successCount = 0;
                    failureCount = 0;
                    elapsedMilliseconds = 0;
                    for (int i = 0; i < currentCount; i++)
                    {
                        Thread t = new Thread(new ThreadStart(DoWork));
                        t.Start();
                    }
                    //阻止主线程，等待测试线程完成测试
                    manualResetEvent.WaitOne();
                    results.Add(new ConcurrentTestResult()
                    {
                        FailureCount = failureCount,
                        SuccessCount = successCount,
                        ElapsedMilliseconds = elapsedMilliseconds
                    });
                    Thread.Sleep(thinkTime);
                }
            }
        }
        /// <summary>
        /// 执行测试方法
        /// </summary>
        private void DoWork()
        {
            bool executeResult;
            Interlocked.Increment(ref currentIndex);
            if (currentIndex < currentCount)
            {
                //等待所有线程创建完毕后同时执行测试
                threadResetEvent.WaitOne();
            }
            else
            {
                //最后一个线程创建完成，通知所有线程，开始执行测试
                threadResetEvent.Set();
                //开始计时
                stopwatch.Start();
            }
            //执行测试
            executeResult = func();
            Interlocked.Decrement(ref currentIndex);
            if (currentIndex == 0)
            {
                //最后一个线程执行的测试结束，结束计时
                stopwatch.Stop();
                elapsedMilliseconds = stopwatch.ElapsedMilliseconds;
                //保存测试结果
                if (executeResult)
                    Interlocked.Increment(ref successCount);
                else
                    Interlocked.Increment(ref failureCount);
                //通知主线程继续
                manualResetEvent.Set();
            }
            else
            {
                //保存测试结果
                if (executeResult)
                    Interlocked.Increment(ref successCount);
                else
                    Interlocked.Increment(ref failureCount);
            }
        }
        #endregion

        #region 释放资源
        /// <summary>
        /// 释放资源
        /// </summary>
        public void Dispose()
        {
            manualResetEvent.Close();
            threadResetEvent.Close();
        }
        #endregion
    }
    /// <summary>
    /// 并发测试结果
    /// </summary>
    public class ConcurrentTestResult
    {
        /// <summary>
        /// 当前执行线程总数
        /// </summary>
        public int ThreadCount
        {
            get { return SuccessCount + FailureCount; }
        }
        /// <summary>
        /// 测试成功数
        /// </summary>
        public int SuccessCount { get; set; }
        /// <summary>
        /// 测试失败数
        /// </summary>
        public int FailureCount { get; set; }
        /// <summary>
        /// 总耗时
        /// </summary>
        public long ElapsedMilliseconds { get; set; }
    }

使用起来就非常简单了，我们看测试代码：

    class Program
    {
        static void Main(string[] args)
        {
            using (ConcurrentTest concurrentTest = new ConcurrentTest())
            {
                var result = concurrentTest.Execute(5, -1, 10, new TestClass().Execute);
                foreach (var item in result)
                {
                    Console.WriteLine("线程数：{0}\t成功：{1}\t失败：{2}\t耗时：{3}",
                        item.ThreadCount, item.SuccessCount, item.FailureCount, item.ElapsedMilliseconds);

                }
            }
            Console.ReadKey(true);
        }
    }

    public class TestClass
    {
        public bool Execute()
        {
            int tempValue = GetRandom();
            System.Threading.Thread.Sleep(tempValue);
            return tempValue % 2 == 0;
        }
        private int GetRandom()
        {
            return new Random().Next(990, 1000);
        }
    }

测试类库提供了4个Execute方法的重载，一般情况下能满足我们的多线程并发测试场景了。

      我们来看mono在腾讯服务器上的CPU报表。

      2月18日到2月24日的平均值在70.91%。而2月23日-3月1日平均值在76.61%。占用的CPU非常高。

      另一份基本相同的代码部署在Windows服务器上，我们看这台服务器的CPU使用率。

      这台服务器除了这个项目外，还负载了其它的Web项目。从报表反映的情况来看，运行状态非常健康。

      这两台服务器的配置分别是：

       Tencent：CPU-Xeon E5506*2(2.13GHZ)，内存-7G，OS-Linux 2.6(suse)，MONO2.8.2

       Windows：CPU-Xeon E5420*4(2.50GHZ)，内存-4G，OS-Windows Server 2003，.NET Framework。

      在服务器的配置上没有办法做直接的对比，附上Windows服务器，只是想从一个侧面来说明项目代码并不复杂，系统需要处理的计划量并不多。

      在访问用户数不高的情况下，单是MONO的守护进程就占用了75.0%的CPU。

      生产环境上是用Apache+mod_mono来做WEB站的，总的来看，对于WEB负载，MONO的情况并不理想。

这次的优化由于时间关系主要分两步走，首先优化应用层代码以提高单台服务器的负载和吞吐率。之后再进行分表，引入队列、MemCached等分布式应用。

项目背景：这是一个在线竞赛的项目(http://race.gwy.591up.com)，在竞赛的时间段内数据库的写入压力很大。

当前问题：1、服务器带宽压力。2、数据库压力。

下图是Web服务器CPU使用率报表。

总体上应用层服务器的CPU使用率不高。

下图是Web服务器带宽报表。

从这个报表可以看到，每块竞赛带宽的占用都会出现一个很高的峰值。

我们再看数据库服务器的带宽报表。

同样的，数据库服务器同样的在竞赛的时间点流量超大，很明显这种情况是不正常的，查询肯定是有问题的。

面对这样的问题，确定了第一期主要做以下的优化。

1、用flash storage做用户做题断点记录。（做题断点：类似程序断点，用户做到第N题时退出做答，下次进入时依然定位到第N题。）这里原来是用数据库存储的，但用户每做一题都会执行一条UPDATE语句，而数据库是MySQL的MyISAM引擎，更新操作经常被堵塞。

2、更改系统交卷行为。原来系统在用户做完提交竞赛后，会执行一条UPDATE语句更新用户提交试卷的时间点。同样的这个UPDATE也是在同一时间段内执行，和产品经理沟通后，确认在最后一分钟的时候可以不用再执行这个更新，允许用户的作答时间有1分钟的误差。

3、调整数据库的更新语句为插入语句，这个优化点因为时间问题，推迟到第二个优化阶段再处理。

4、调整应用服务器以支持LVS集群。对当前系统进行分析后，暂时可以不用调整代码直接部署集群，问题是在多台服务器内都会存在相同的进程内缓存，这种情况暂时是可以接受的，后期需要改到MemCached集中管理缓存。

5、等待成绩页面同一时间跳转的压力问题。在线竞赛的提交时间点很集中，用户做答完题目后，会统一跳转到一个页面等待答案（这时后台的Windows 服务在进行竞赛统计），这里服务器的并发、带宽压力都非常大。因此，优化这里不进行跳转，而是在当前的页面等待，并且会自动给不同的用户分配不同的等待时间，以避免占满服务器的带宽。

6、每场完整的公务员考试试卷，题目资源有150K-200K，因为作答和查看解析是在不同的页面，之前的实现会造成题目的多次加载，严重的浪费了带宽资源。于是这里优化成Handler输入静态资源加载，从服务器加载一次之后，后面所有的地方调用到题目都可以从浏览器的本地缓存中加载带省服务器带宽。同时，服务器上只对静态资源服务器开启了GZip压缩，对动态文件进行压缩会浪费服务器的CPU资源，而只对Handler输出的题目进行GZip压缩，一方面节省了CPU，另一方面把150K-200K的题目资源压缩到了50K左右。

7、数据库性能优化。调整了代码中查询的各个条件的位置，使查询语句能够更多的使用到索引。同时把原来每次一条的插入操作修改为一次插入多条等一些数据库查询优化。

任何一个优化都要针对已经存在的问题，从服务器监控的报表可以看到我们这个网站应用服务器带宽压力、数据库服务器带宽压力都很大，应用服务器的CPU使用率不高，因此，主要的优化是对应用服务器带宽和数据库服务器的写入压力做的优化，因为目的很明确，效果也是比较明显的。

文中提到了用Handler来输出静态资源让浏览器缓存，附上这个代码，其它的优化针对性很高，就不再啰嗦了，主要的还是记录下这次优化的工作方式和工作方法。

Handler输出的静态资源使用了.NET流压缩，于是我们声明一个压缩器接口。

using System.IO;

namespace ND.Race.Compressor
{
    /// <summary>
    /// 压缩器接口
    /// </summary>
    public interface ICompressor
    {
        string EncodingName { get; }
        bool CanHandle(string acceptEncoding);
        void Compress(string content, Stream targetStream);
    }
}

GZip压缩器实现这个接口。

using System.IO;
using System.IO.Compression;
using System.Text;

namespace ND.Race.Compressor
{
    public sealed class GZipCompressor : ICompressor
    {
        public string EncodingName
        {
            get { return "gzip"; }
        }

        public bool CanHandle(string acceptEncoding)
        {
            return !string.IsNullOrEmpty(acceptEncoding) &&
                   acceptEncoding.Contains("gzip");
        }

        public void Compress(string content, Stream targetStream)
        {
            using (var writer = new GZipStream(targetStream, CompressionMode.Compress))
            {
                var bytes = Encoding.UTF8.GetBytes(content);
                writer.Write(bytes, 0, bytes.Length);
            }
        }
    }
}

同样的Deflate压缩器也实现这个接口。

using System.IO;
using System.IO.Compression;
using System.Text;

namespace ND.Race.Compressor
{
    public sealed class DeflateCompressor : ICompressor
    {
        public string EncodingName
        {
            get { return "deflate"; }
        }

        public bool CanHandle(string acceptEncoding)
        {
            return !string.IsNullOrEmpty(acceptEncoding) &&
                   acceptEncoding.Contains("deflate");
        }

        public void Compress(string content, Stream targetStream)
        {
            using (var writer = new DeflateStream(targetStream, CompressionMode.Compress))
            {
                var bytes = Encoding.UTF8.GetBytes(content);
                writer.Write(bytes, 0, bytes.Length);
            }
        }
    }
}

如果浏览器不支持流压缩，那我们只能直接输出内容了，因此我们还需要一个不进行压缩的处理类。

using System.IO;
using System.Text;

namespace ND.Race.Compressor
{
    public sealed class NullCompressor : ICompressor
    {
        public string EncodingName
        {
            get { return "utf-8"; }
        }

        public bool CanHandle(string acceptEncoding)
        {
            return true;
        }

        public void Compress(string content, Stream targetStream)
        {
            using (targetStream)
            {
                var bytes = Encoding.UTF8.GetBytes(content);
                targetStream.Write(bytes, 0, bytes.Length);
            }
        }
    }
}

现在我们就可以开始编码我们的Handler了。

public class QuestionCacheHandler : IHttpHandler
{
    #region 静态变量
    /// <summary>
    /// 资源过期时间
    /// </summary>
    private static readonly int durationInDays = 30;
    /// <summary>
    /// 流压缩接口
    /// </summary>
    private static readonly ICompressor[] Compressors = {
                                                                new GZipCompressor(),
                                                                new DeflateCompressor(),
                                                                new NullCompressor()
                                                            };
    #endregion

    #region 私有变量
    /// <summary>
    /// 内存流压缩类
    /// </summary>
    private ICompressor compressor;
    /// <summary>
    /// ETAG
    /// </summary>
    private string eTagCacheKey;
    /// <summary>
    /// 竞赛场次Id
    /// </summary>
    private long raceId;
    #endregion

    public void ProcessRequest(HttpContext context)
    {
        if (context == null) return;

        long.TryParse(context.Request.QueryString["raceId"], out raceId);
        if (raceId == 0) return;        

        var acceptEncoding = context.Request.Headers["Accept-Encoding"];
        compressor = Compressors.First(o => o.CanHandle(acceptEncoding));
        eTagCacheKey = string.Concat(raceId, "/etag");
        if (IsInBrowserCache(context, eTagCacheKey)) return;
        SendOutputToClient(context, true, eTagCacheKey);
    }

    /// <summary>
    /// 发送内容到客户端
    /// </summary>
    /// <param name="context"></param>
    /// <param name="insertCacheHeaders"></param>
    /// <param name="etag"></param>
    private void SendOutputToClient(HttpContext context, bool insertCacheHeaders, string etag)
    {
        string content = "";
        MemoryStream memoryStream = new MemoryStream();
        compressor.Compress(content, memoryStream);
        byte[] bytes = memoryStream.ToArray();
        HttpResponse response = context.Response;
        if (insertCacheHeaders)
        {
            HttpCachePolicy cache = context.Response.Cache;
            cache.SetETag(etag);
            cache.SetOmitVaryStar(true);
            cache.SetMaxAge(TimeSpan.FromDays(durationInDays));
            cache.SetLastModified(DateTime.Now);
            cache.SetExpires(DateTime.Now.AddDays(durationInDays)); // HTTP 1.0 的浏览器使用过期时间
            cache.SetValidUntilExpires(true);
            cache.SetCacheability(HttpCacheability.Public);
            cache.SetRevalidation(HttpCacheRevalidation.AllCaches);
            cache.VaryByHeaders["Accept-Encoding"] = true;
        }
        response.AppendHeader("Content-Length", bytes.Length.ToString(System.Globalization.CultureInfo.InvariantCulture));
        response.ContentType = "text/plain";
        response.ContentType = "application/x-javascript";
        response.AppendHeader("Content-Encoding", compressor.EncodingName);
        if (bytes.Length > 0)
            response.OutputStream.Write(bytes, 0, bytes.Length);
        if (response.IsClientConnected)
            response.Flush();
    }

    /// <summary>
    /// 是否浏览器已经缓存
    /// </summary>
    /// <param name="context"></param>
    /// <param name="etag"></param>
    /// <returns></returns>
    private bool IsInBrowserCache(HttpContext context, string etag)
    {
        string incomingEtag = context.Request.Headers["If-None-Match"];
        if (String.Equals(incomingEtag, etag, StringComparison.Ordinal))
        {
            context.Response.Cache.SetETag(etag);
            context.Response.AppendHeader("Content-Length", "0");
            context.Response.StatusCode = (int)System.Net.HttpStatusCode.NotModified;
            context.Response.End();
            return true;
        }
        return false;
    }

    public bool IsReusable
    {
        get
        {
            return false;
        }
    }
}

服务器端代码通过Http请求Header的Accept-Encoding来判断是否支持流压缩，再通过Header的etag来判断浏览器中是否已经有缓存副本。

      1、应用服务器层的水平扩展。实现应用服务器层的负载均衡，是实现应用服务器水平扩展的最主要手段，具体实现负载均衡的策略有以下两种：
      a.基于硬件负载均衡设备实现负载均衡，如F5设备。
      b.基于软件的方式实现负载均衡，例如通过配置Apache Http Server。

      Apache可以实现负载均衡，根据服务器的压力情况，将每个用户请求分布到不同的应用服务器上。但大部分应用的用户请教是有状态的（一般使用Session记录用户状态）。这种情况下，如何能够在多台应用服务器之间保持用户状态，将是实现应用服务器层水平扩展的关键。
      a.Session复制。Session复制的技术实现非常复杂，在大规模集群中实用性并不强，服务器之间大量的Session复制会严重影响这些服务器的性能。而随着服务器数量的增加，这种性能影响会显得更加突出，甚至不可接受。在大部分互联网应用中，Session复制技术应该是很少采用的。
      b.Session Sticky。为了避免Session复制所带来的性能影响，更简单、也是更高效的一种做法是Session Sticky。这种方式将同一用户的请求转发到特定的JBoss服务器上，避免了集群中Session的复制。Session Sticky的实现非常简单，但是这种方式不能满足fail-over的需求。即当一台应用服务器down的时候，这台服务器上正在访问的所有用户的Session都失效了，所有用户不得不再次重新登录。而且这种方式还容易导致负载不够均衡。
      c.基于Cache的集中式Session。这种方案通常使用集中式的Cache来代替本地Session。集中式的Session服务器采用的是MemCached，其本身也具备水平扩展能力。当Session数量大到一台Cache服务器都不能承受的程度时，我们也仅需要增加相应的Cache服务器即可。

      三种水平扩展方式的比较：

      2、数据库层的水平扩展。相对于应用服务器层的水平扩展，数据库层的水平扩展更难实现。实现数据库的水平扩展也有多种方式：
      a.数据库的垂直切分：将不同的功能模块所涉及的表划分到不同的物理数据库中，从而将对这些表的访问压力分担到多个不同的物理数据库中。
      b.数据库的读/写分离：同一个数据库在多个物理服务器上具有多份Copy，彼此同步。然后将对于数据库的写操作都统一到一个主服务器上，而读操作则分摊到多台从服务器上。通过读/写分离，实现数据库访问压力的分担。
      c.数据库的水平切分：将原来存储在一个数据表中的数据，按照一定的规则，切分到多个不同的物理数据库中。每个数据库的数据结构完全相同，但是数据各不相同。最终对于业务数据的访问，会根据其数据所在的数据库，定位到某一个数据库中查询。

      2.1、数据库的垂直切分。尽管数据库的垂直切分是最容易想到的，但对于大部分应用而言，除非模块间的关联很少，否则要实现垂直切分也不容易：
      a.原本可能存在的表连接，需要想办法去除。
      b.原本同一个数据库的事务操作，可能会变成跨库事务。可见数据库的垂直切分是一个可以适当采用，但很难广泛采用的数据库层扩展技术。

      2.2、数据库的读/写分离技术。对于读多写少的互联网应用，会广泛采用读/写分离技术。尽管Slave Database Server数量是可以线性扩展的，但是基于以下两个原因，Slave Database Server也不是越多越好。
      a.如果应用读/写比例不是很悬殊，单纯增加Slave Database Server对于应用性能提升并且没有特别的作用，通常情况下，Slave Server的数量与读/写比例对应。
      b.Slave Database Server过多可能造成Master-Slave之间的同步性能降低。

      2.3、数据库的水平切分。无论数据库的垂直切分还是读/写分离，对于实现数据库层的水平扩展，适用范围都比较狭窄。数据库的水平切分，通常有两种处理方式：
      a.一种是采用Hash算法。采用Hash算法实现更为简单，性能也高，但是扩展性略差。因为Hash算法一开始就确定，如果后面变更的话，会涉及数据的迁移。
      b.另一种是将对应到哪个物理数据库也作为关系表存储在集中式的租户数据库中。这种方式更为常见。在用户登录时，通过查询相应的关系表，即可以确定其对应租房的业务数据存储在具体的哪个物理数据库中。

      三种数据库层的水平扩展方案对比：

      1、数据库层性能优化

      1.1、建立合适的索引。建立合适的索引对基于数据库的应用都非常重要。建立合适的索引要注意以下几个问题：
      a.索引应该创建在条件(WHERE)，排序(ORDER BY)，分组(GROUP BY)等操作所涉及的列上。
      b.索引应该有较强的选择性，即应尽可能建立在重复数据少的数据列中。
      c.如果多个条件经常需要组合起来查询，应合理使用联合索引。
      d.一次查询中只能使用一个索引，可使用相应的分析工具分析索引效果。
      e.索引不是越多越好，过多的索引可能导致CUD(新增、修改、删除)的性能降低，并且占用更多的空间。
      另外一个，在互联网应用中不应该使用包含LIKE的模糊查询，要实现模糊查询，更适合的方式是搜索引擎。

      1.2、消除大数据表连接。消除表连接有以下几种解决方案。

      1.3、避免复杂SQL。避免复杂的SQL可以参考这样一个原则：一般需要考虑把复杂的SQL分解成多个简单的SQL执行，将复杂的运算尽量留在应用服务器层。因为一般情况下，应用服务器层的水平扩展更容易实现，而数据库层的扩展是比较困难的。

      2、应用层性能优化。应用层不是首先提及的性能优化对象，原因是在大部分情况下，应用层更容易通过简单的水平扩展来增强系统处理能力。应用层常见的优化策略有这些：

      2.1、Cache。其实很难说Cache就是应用层的优化策略。互联网应用属于“读多写少”，这种情况下做Cache，其实也是对数据库层的一种优化，因为避免了对于数据库的频繁访问。总的说来，Cache应用具备如下特征：
      a.需要Cache的数据应该是读多写少的。
      b.由于Cache数据是易失的，因为为了保证可靠性，一般情况下应用中还需要增加一层逻辑：当Cache中访问不到时，需要访问数据库，并重新将其载入Cache。

      2.2、统计和报表。为了缓解实时计算给数据库带来的巨大压力，统计和报表运算有如下的一些优化策略，不过具体的优化策略还是跟应用场景相关。
      a.对于统计结果实时性不高的，并且历史数据是不允许修改的情况下，通常可以采用后台任务定时统计的策略。
      b.如果历史数据是可以修改的，则相应的后台任务定时统计方案会略有些复杂：对于被修改的历史数据，历史统计结果和报表需要重新运算。
      c.对于部分统计结果实时性要求很高的功能，则可以在后台任务定时统计的基础上，再加上增量数据实时统计的结果。

      2.3、使用全文索引进行搜索。

      2.4、异步操作。异步操作并没有从本质上提升系统性能或者数据吞吐量。但是异步操作使得用户体验得到了极大的提升，同时也能降低系统的并发负载。因此，将同步操作变成异步操作也是提升性能的一种重要手段。

      3、Web层性能优化。关于Web层性能优化主要有Web开发的性能优化和Http服务器的性能优化。Web开发的性能优化可以查阅我的《页面加载时间优化笔记》。

腾讯社区开放平台提供的体验区的服务器环境是这样的：

操作系统：Linux version 2.6.16.60 (gcc version 4.1.2 20070115 (SUSE Linux))

这个Linux内核的版本号应该是SLES（SUSE Linux Enterprise Server 10 SP2）的操作系统。mono原来的版本号是1.2.2，而我们需要2.8.2的mono。所以，第一步的工作就是升级mono。

通过腾讯的跳板机登录到服务器后，需要跟腾讯的运维人员申请root权限，这个就不用多说了。

部署mono环境的具体步骤如下：

1、下载mono并上传到腾讯的服务器上。

腾讯的服务器是没有配置dns解析功能的，所以不能直接用yast2来通过更新源来升级mono；对于可以用yast2安装的，可以参考我的《在openSUSE中部署基于apache的mono环境》。而用rpm手工安装，太多的程序依赖处理起来很麻烦，只好用通过编译mono源码的方式来安装了。

在这里可以下载到mono的源码，我们只需要mono-2.8.tar.bz2/xsp-2.8.tar.bz2/mod_mono-2.8.tar.bz2。mono-2.8.tar.bz2当然是mono的核心了，xsp-2.8.tar.bz2是一个轻量级的web服务器，而mod_mono-2.8.tar.bz2是apache的模块，使用这个来解析.net开发的网站。

上传文件到腾讯的服务器需要分2部走，首先用rz -be把文件上传到腾讯的跳板机，然后再用scp命令把文件传到目标服务器。

2、安装mono-2.8.tar.bz2。

切换到mono-2.8.bar.bz2的目录，执行

tar xf mono-2.8.tar.bz2

解压mono源码包。之后再

cd mono-2.8

进入解压出来的文件夹后，执行配置命令，这里都使用默认配置，如果使用–prefix指定目录的话，需要修改很多配置，操作起来非常麻烦。

./configure

之后就是最常规的

make

进入漫长的编译过程。中间过程如果出错，根据它的提示安装相当的文件。然后直接进行安装。

make install

到这里，mono就安装完成了。这步非常简单。我走的弯路是腾讯要求要把软件都安装到/usr/local/services/目录，而mono指定安装目录后，需要设置系统变量及在后面的软件安装过程都要显式的指定mono目录，一直都没有折腾好，最后只好使用默认安装，结果一次就好了。

3、安装xsp-2.8.tar.bz2。

一样解压文件并执行configure，

tar xf xsp-2.8.tar.bz2
cd xsp-2.8
./configure

到这里一直都是正确的，但是执行

make

的时候，就不能进行下去了。会有这样一个提示：

Your sqlite3 version is old – please upgrade to at least v3.5.0!

Unhandled Exception:System.EntryPointNotFoundException: sqlite3_next_stmt

…….

提示这个错误是因为linux本身的sqlite3版本号不够，默认的是3.1.3。你要么升级sqlite要么修改xsp的文件。查看xsp的安装文件发现是在编译xsp的demo文件时产生的错误。在$XSP_PATH/test/1.1/webcontrols目录下有dbpage1.aspx/dbpage1.sqlite/dbpage2.aspx/dbpage2.sqlite/dbpage_test_setup.cs这几个文件，错误就是在编译这些文件的时候产生的。于是我修改了这个目录下的Makefile/Makefile.am/Makefile.in这三个文件，把和sqlite有关的都删除掉了。

分别编辑这三个文件，找到：

samples_Data =

把这个值的

dbpage1.aspx \
dbpage2.aspx \

把这两个删掉，还有：

sqlitedir = $(pkglibdir)/test/1.1/webcontrols
sqlite_DATA = dbpage.sqlite \
                       dbpage2.sqlite

samplesbindir = ....
samplesbin_SCRIPTS = ...
dbpage_test_setup_build = ...
EXTRA_Dist = $(sqlite_DATA) ...
all: all-am

这些都删掉。在页面的底部还有：

dbpage_test_setup.exe :$(dbpage_test_setup_build)....
# ...... 一直到 ......
dbpage2.sqlite: dbpage_test_setup.exe
    $(RUNTIME) dbpage_test_setup.exe

全部都需要删掉。三个页面都执行这样的删除操作。删除完后，再make，就能成功编译了。完了再

make install

安装mono最麻烦的问题就是这里编译出错。网上查这个编译错误，貌似很多人都有遇到，但是又都没有说怎么解决。期间我还尝试升级sqlite3，可是没有升级成功。最后一个文件一个文件打开来看，才发现Makefile文件的秘密。主要是第一次折腾linux系统，所以多走了很多弯路。

4、安装mod_mono-2.8.tar.bz2。

安装这个也没有遇到什么问题，主要是如果你的apache文件不是安装在默认目录的，需要在configure命令时指定apache的bin目录。

5、都安装好后，剩下的就是配置apache了。

编辑$APACHE_PATH/conf/httpd.conf文件，增加一个配置：

#Mono module
Include conf/mod_mono.conf

安装mod_mono之后，这个mod_mono.cnf是自动生成的，和apache的httpd.conf在相同的目录。

对于网站的配置，Mono的官方网站有一个mod_mono的配置生成工具，建议使用里面的Virtual Host的方式来生成配置文件。它能帮我们生成这样的配置文件：

<VirtualHost *:80>
  ServerName mono.moozi.net
  ServerAdmin moozi@moozi.net
  DocumentRoot /srv/www/mono.moozi.net
  # MonoServerPath can be changed to specify which version of ASP.NET is hosted
  # mod-mono-server1 = ASP.NET 1.1 / mod-mono-server2 = ASP.NET 2.0
  # For SUSE Linux Enterprise Mono Extension, uncomment the line below:
  # MonoServerPath mono.moozi.net "/opt/novell/mono/bin/mod-mono-server2"
  # For Mono on openSUSE, uncomment the line below instead:
  MonoServerPath mono.moozi.net "/usr/bin/mod-mono-server2"

  # To obtain line numbers in stack traces you need to do two things:
  # 1) Enable Debug code generation in your page by using the Debug="true"
  #    page directive, or by setting <compilation debug="true" /> in the
  #    application's Web.config
  # 2) Uncomment the MonoDebug true directive below to enable mod_mono debugging
  MonoDebug mono.moozi.net true

  # The MONO_IOMAP environment variable can be configured to provide platform abstraction
  # for file access in Linux.  Valid values for MONO_IOMAP are:
  #    case
  #    drive
  #    all
  # Uncomment the line below to alter file access behavior for the configured application
  MonoSetEnv mono.moozi.net MONO_IOMAP=all
  #
  # Additional environtment variables can be set for this server instance using
  # the MonoSetEnv directive.  MonoSetEnv takes a string of 'name=value' pairs
  # separated by semicolons.  For instance, to enable platform abstraction *and*
  # use Mono's old regular expression interpreter (which is slower, but has a
  # shorter setup time), uncomment the line below instead:
  # MonoSetEnv mono.moozi.net MONO_IOMAP=all;MONO_OLD_RX=1

  MonoApplications mono.moozi.net "/:/srv/www/mono.moozi.net"
  <Location "/">
    Allow from all
    Order allow,deny
    MonoSetServerAlias mono.moozi.net
    SetHandler mono
  </Location>
</VirtualHost>

为了提高apache的处理性能，我们需要对这个配置再做一些修改，最后的配置如下：

<VirtualHost *:80>
  ServerName mono.moozi.net
  ServerAdmin mono@moozi.net
  DocumentRoot /srv/www/mono.moozi.net/

  MonoServerPath mono.moozi.net "/usr/local/bin/mod-mono-server4" #这里我用.net 4.0
  MonoDebug mono.moozi.net true
  MonoSetEnv mono.moozi.net MONO_IOMAP=all  

  MonoApplications mono.moozi.net  "/:/srv/www/mono.moozi.net/"
  <Location "/">
    Allow from all
    Order allow,deny
    MonoSetServerAlias mono.moozi.net
    SetHandler mono
  </Location>
  <Location ~ "^/(styles|scripts|images)/">
    SetHandler default-handler
  </Location>
  <Location ~ "^/[^/]+\.(txt|html|ico|js|css|jpg|jpeg|gif|png)">
    SetHandler default-handler
  </Location>
</VirtualHost>

这里我们增加了两个<Location />配置节，让静态资源文件使用apache的默认handler处理。

最后，重启apache就好了。

经过了近一周时间的折腾，终于成功地在腾讯社区开放平台部署好MONO环境。

我们的应用是腾讯社区开放平台的首个.NET应用，测试了一下午，程序运行状态良好。从感官上来看，响应比IIS还快…当然，事实还有待于验证。

杯具的是腾讯体验区的web服务器今天封网了，要年后初九才能上线到体验区…

首先，要把.NET Framework的应用迁移到mono平台，一定要借助这个软件：MoMA。Mono Migration Analyzer (Moma)是一个用于开发者使用的MS .net下开发的应用程序迁移到Mono平台的不兼容性检测工具。工具通过分析.dll或者.exe程序集的代码是否符合ECMA CLI，大家都知道符合ECMA CLI标准的.net 程序可以运行于MS .net和Mono平台。这个工具可以帮助我们生成一个很详细的mono兼容性文档，可以帮助我们调整程序的兼容性。

不过这个工具的分析结果也不完全正确，一些实现方式MoMA提示不兼容，但在mono中是可以正常使用的。

遇到的一些不兼容的问题：

1、项目是使用JS来调用Web Services来做的，用xsp做WEB服务器端的时候发现如果Web Services接口中有使用可空参数的时候，不能正常使用，即使回传的值不是null，接口依然只能接收到null值。

2、如果使用nginx通过调用mono的fastcgi来做WEB服务器，这种方式将不支持Web Services。Apache的mod_mono暂未做测试。

3、在mono环境中，TimeZoneInfo.Local无法使用，这是mono的一个BUG。

4、MySQL Connector的mono版本中有2个类库，一个是.net 2.0，一个是.net 4.0。如果把2.0的类库也用MoMA分析，会提示很多不支持的方法；如果你是用nginx的fastcgi解析.net程序，需要使用4.0的MySQL类库；而在xsp中，使用2.0的类库就好了。

5、如果你的操作系统是SLES，建议获取mono的源码编译完装，会让你省去很多事情。

6、在SLES编译XSP源码时，你系统的sqlite3的版本号要大于3.5.0，否则编译不过。

7、把项目转到mono平台，风险还是非常大的，非常多第三方类库不能直接在mono平台中使用，如Combres/log4net/Quartz.NET等等，都需要修改源代码。

暂时先整理这些问题，后面会补上在SLES中部署mono环境的详细过程。

总的说来，mono整体的兼容性是非常不错的，在linux中跑起来很流畅，mono 2.8.2已经不再是玩具了。关于mono，园子里的geffzhang有很深入的研究，有兴趣的同学可以去看看他的博客。