void CompressContent(object sender, EventArgs e) ...{
HttpApplication app = (HttpApplication)sender;
      if(!app.Context.Items.Contains(INSTALLED_KEY)) ...{
//设置标志避免重复压缩
        app.Context.Items.Add(INSTALLED_KEY, INSTALLED_TAG);

//设置缓存敏感参数
       app.Response.Cache.VaryByHeaders["Accept-Encoding"] = true;

//根据Accept-Encoding寻找合适的压缩过滤模块CompressingFilter : HttpOutputFilter;
//如果没有设置Accept-Encoding，或者寻找失败均是直接返回，即不压缩
...
CompressingFilter filter = GetFilterForScheme(types, app.Response.Filter, settings);
        if(filter == null)...{
          // if we didn't find a filter, bail out
          return;
        }
        app.Response.Filter = filter;
}
}

using System;
using System.IO;

namespace blowery.Web.HttpCompress ...{
  /**//// <summary>
  /// The base of anything you want to latch onto the Filter property of a <see cref="System.Web.HttpResponse"/>
  /// object.
  /// </summary>
  /// <remarks>
  /// <p></p>These are generally used with <see cref="HttpModule"/> but you could really use them in
  /// other HttpModules.  This is a general, write-only stream that writes to some underlying stream.  When implementing
  /// a real class, you have to override void Write(byte[], int offset, int count).  Your work will be performed there.
  /// </remarks>
  public abstract class HttpOutputFilter : Stream ...{
    
    private Stream _sink;

    /**//// <summary>
    /// Subclasses need to call this on contruction to setup the underlying stream
    /// </summary>
    /// <param name="baseStream">The stream we're wrapping up in a filter</param>
    protected HttpOutputFilter(Stream baseStream) ...{ 
      _sink = baseStream;
    }

    /**//// <summary>
    /// Allow subclasses access to the underlying stream
    /// </summary>
    protected Stream BaseStream ...{
      get...{ return _sink; }
    }

    /**//// <summary>
    /// False.  These are write-only streams
    /// </summary>
    public override bool CanRead ...{
      get ...{ return false; }
    }

    /**//// <summary>
    /// False.  These are write-only streams
    /// </summary>
    public override bool CanSeek ...{
      get ...{ return false; }
    }

    /**//// <summary>
    /// True.  You can write to the stream.  May change if you call Close or Dispose
    /// </summary>
    public override bool CanWrite ...{
      get ...{ return _sink.CanWrite; }
    }

    /**//// <summary>
    /// Not supported.  Throws an exception saying so.
    /// </summary>
    /// <exception cref="NotSupportedException">Thrown.  Always.</exception>
    public override long Length ...{
      get ...{ throw new NotSupportedException(); }
    }

    /**//// <summary>
    /// Not supported.  Throws an exception saying so.
    /// </summary>
    /// <exception cref="NotSupportedException">Thrown.  Always.</exception>
    public override long Position ...{
      get ...{ throw new NotSupportedException(); }
      set ...{ throw new NotSupportedException(); }
    }

    /**//// <summary>
    /// Not supported.  Throws an exception saying so.
    /// </summary>
    /// <exception cref="NotSupportedException">Thrown.  Always.</exception>
    public override long Seek(long offset, System.IO.SeekOrigin direction) ...{
      throw new NotSupportedException();
    }

    /**//// <summary>
    /// Not supported.  Throws an exception saying so.
    /// </summary>
    /// <exception cref="NotSupportedException">Thrown.  Always.</exception>
    public override void SetLength(long length) ...{
      throw new NotSupportedException();
    }
    
    /**//// <summary>
    /// Closes this Filter and the underlying stream.
    /// </summary>
    /// <remarks>
    /// If you override, call up to this method in your implementation.
    /// </remarks>
    public override void Close() ...{
      _sink.Close();
    }

    /**//// <summary>
    /// Fluses this Filter and the underlying stream.
    /// </summary>
    /// <remarks>
    /// If you override, call up to this method in your implementation.
    /// </remarks>
    public override void Flush() ...{
      _sink.Flush();
    }

    /**//// <summary>
    /// Not supported.
    /// </summary>
    /// <param name="buffer">The buffer to write into.</param>
    /// <param name="offset">The offset on the buffer to write into</param>
    /// <param name="count">The number of bytes to write.  Must be less than buffer.Length</param>
    /// <returns>An int telling you how many bytes were written</returns>
    public override int Read(byte[] buffer, int offset, int count) ...{
      throw new NotSupportedException();
    }

  }
}

using System;
using System.IO;
using System.Web;

namespace blowery.Web.HttpCompress ...{
  /**//// <summary>
  /// Base for any HttpFilter that performing compression
  /// </summary>
  /// <remarks>
  /// When implementing this class, you need to implement a <see cref="HttpOutputFilter"/>
  /// along with a <see cref="CompressingFilter.ContentEncoding"/>.  The latter corresponds to a 
  /// content coding (see http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.5)
  /// that your implementation will support.
  /// </remarks>
  public abstract class CompressingFilter : HttpOutputFilter ...{

    private bool hasWrittenHeaders = false;

    /**//// <summary>
    /// Protected constructor that sets up the underlying stream we're compressing into
    /// </summary>
    /// <param name="baseStream">The stream we're wrapping up</param>
    /// <param name="compressionLevel">The level of compression to use when compressing the content</param>
    protected CompressingFilter(Stream baseStream, CompressionLevels compressionLevel) : base(baseStream) ...{
      _compressionLevel = compressionLevel;
    }

    /**//// <summary>
    /// The name of the content-encoding that's being implemented
    /// </summary>
    /// <remarks>
    /// See http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.5 for more
    /// details on content codings.
    /// </remarks>
    public abstract string ContentEncoding ...{ get; }

    private CompressionLevels _compressionLevel;

    /**//// <summary>
    /// Allow inheriting classes to get access the the level of compression that should be used
    /// </summary>
    protected CompressionLevels CompressionLevel ...{
      get ...{ return _compressionLevel; }
    }

    /**//// <summary>
    /// Keeps track of whether or not we're written the compression headers
    /// </summary>
    protected bool HasWrittenHeaders ...{ 
      get ...{ return hasWrittenHeaders; } 
    }

    /**//// <summary>
    /// Writes out the compression-related headers.  Subclasses should call this once before writing to the output stream.
    /// </summary>
    protected void WriteHeaders() ...{
      // this is dangerous.  if Response.End is called before the filter is used, directly or indirectly,
      // the content will not pass through the filter.  However, this header will still be appended.  
      // Look for handling cases in PreRequestSendHeaders and Pre
      HttpContext.Current.Response.AppendHeader("Content-Encoding", this.ContentEncoding);
      //HttpContext.Current.Response.AppendHeader("X-Compressed-By", "HttpCompress");
      hasWrittenHeaders = true;
    }


  }
}

using System;
using System.IO;

using System.IO.Compression;

namespace blowery.Web.HttpCompress ...{
  /**//// <summary>
  /// Summary description for DeflateFilter.
  /// </summary>
  public class DeflateFilter : CompressingFilter ...{

    /**//// <summary>
    /// compression stream member
    /// has to be a member as we can only have one instance of the
    /// actual filter class
    /// </summary>
    private DeflateStream m_stream = null;

    /**//// <summary>
    /// Basic constructor that uses the Normal compression level
    /// </summary>
    /// <param name="baseStream">The stream to wrap up with the deflate algorithm</param>
    public DeflateFilter(Stream baseStream) : this(baseStream, CompressionLevels.Normal) ...{ }

    /**//// <summary>
    /// Full constructor that allows you to set the wrapped stream and the level of compression
    /// </summary>
    /// <param name="baseStream">The stream to wrap up with the deflate algorithm</param>
    /// <param name="compressionLevel">The level of compression to use</param>
    public DeflateFilter(Stream baseStream, CompressionLevels compressionLevel) : base(baseStream, compressionLevel) ...{
        m_stream = new DeflateStream(baseStream, CompressionMode.Compress);
    }

    /**//// <summary>
    /// Write out bytes to the underlying stream after compressing them using deflate
    /// </summary>
    /// <param name="buffer">The array of bytes to write</param>
    /// <param name="offset">The offset into the supplied buffer to start</param>
    /// <param name="count">The number of bytes to write</param>
    public override void Write(byte[] buffer, int offset, int count) ...{
      if(!HasWrittenHeaders) WriteHeaders();
      m_stream.Write(buffer, offset, count);
    }

    /**//// <summary>
    /// Return the Http name for this encoding.  Here, deflate.
    /// </summary>
    public override string ContentEncoding ...{
      get ...{ return "deflate"; }
    }

    /**//// <summary>
    /// Closes this Filter and calls the base class implementation.
    /// </summary>
    public override void Close() ...{
      m_stream.Close();
    }

    /**//// <summary>
    /// Flushes that the filter out to underlying storage
    /// </summary>
    public override void Flush() ...{
      m_stream.Flush();
    }
  }
}