一个具有缓存数据功能的HttpWebRequest工具类

背景：一个公共站点中的数据，供其它子站点共享，为了提高性能，简单实现了Http 1.1的缓存功能

特点：可以缓存Html数据到内存中;缓存具有过期时间;缓存过期后，通过再确认的方式来决定是否更新缓存;浏览器刷新后，无论缓存是否过期都会强制再验证;

未实现的包括：不能通过no-store来强制清空缓存，缓存再确认时没有验证Etag

/// <summary>
/// 启用缓存的HttpRequest
/// </summary>
public static class CacheHttpRequest
{
private static Dictionary<String,HtmlLocalCache> _caches = new Dictionary<string,HtmlLocalCache>();
private static object AddCacheLock = new Object();

public static String GetHtml(String url)
{
HtmlLocalCache cache;
//如果有缓存，且缓存尚未过期，或不需要重新验证，则直接返回内容
if(_caches.TryGetValue(url,out cache))
{
if(!cache.NeedRevalidate())
{
return cache.Html;
}
}

var webRequest = (HttpWebRequest)WebRequest.Create(url);
//如果有缓存，且需要重新验证，则设置它的IMS信息，为了简便，这里没有验证ETag
if(cache != null)
{
webRequest.IfModifiedSince = cache.LastModified;
}

HttpWebResponse response = null;
Stream stream = null;
try
{
response = webRequest.GetHttpResponse();
//如果服务器资源没有修改，则修改缓存信息后，返回内容
if (cache != null && response.StatusCode == HttpStatusCode.NotModified)
{
cache.UpdateCacheProperty(response);
return cache.Html;
}

//服务器资源已经修改，重新获取内容，并放入缓存
if (response.StatusCode == HttpStatusCode.OK)
{
stream = response.GetResponseStream();
TextReader reader = new StreamReader(stream);

cache = new HtmlLocalCache();
cache.SetCacheProperty(response);
cache.Html = reader.ReadToEnd();
AddHtmlToCache(url, cache);

return cache.Html;
}

return "";
}
finally
{
if(response != null) response.Close();
if(stream != null) stream.Dispose();
}
}

private static void AddHtmlToCache(string url, HtmlLocalCache cache)
{
lock (AddCacheLock)
{
if (!_caches.ContainsKey(url))
{
_caches.Add(url, cache);
}
}
}

/// <summary>
/// 缓存数据
/// </summary>
private class HtmlLocalCache
{
public String Html;
public DateTime LastModified;
public DateTime? ExpiredTime;
public DateTime HttpDate;
private Object _updateLock = new Object();

public Boolean NeedRevalidate()
{
if (ExpiredTime == null) return true;
if (FromRefresh()) return true;
return DateTime.Now > ExpiredTime;
}

/// <summary>
/// 看是否是页面刷新
/// </summary>
/// <returns></returns>
private static bool FromRefresh()
{
string requestCacheControl = HttpContext.Current.Request.Headers["Cache-Control"];
String pragma = HttpContext.Current.Request.Headers["Pragma"];
Boolean isRefresh = (pragma != null &&
pragma.Equals("no-cache", StringComparison.OrdinalIgnoreCase)
|| requestCacheControl != null &&
requestCacheControl.Equals("no-cache", StringComparison.OrdinalIgnoreCase));

if (isRefresh) return true;
return false;
}

private void SetCacheControl(string cacheControl)
{
if (String.IsNullOrEmpty(cacheControl)) return;

if(cacheControl.Contains("max-age"))
{
Double maxAge = Double.Parse(cacheControl.Substring(cacheControl.IndexOf('=')+1));
ExpiredTime = HttpDate.AddSeconds(maxAge);
}
}

public void SetCacheProperty(HttpWebResponse response)
{
LastModified = response.LastModified;
HttpDate = Convert.ToDateTime(response.Headers["Date"]);
//使用cache-control来控制缓存过期时间，不使用expires
SetCacheControl(response.Headers["Cache-Control"]);
}

public void UpdateCacheProperty(HttpWebResponse response)
{
lock (_updateLock)
{
SetCacheProperty(response);
}
}
}
}