如何在 ASP.NET MVC 控制器中使用 Lazy<T>？

Question

我有一个简单的ASP.NET MVC 控制器。在几个操作方法中，我访问了一个资源，我会说很昂贵。

所以我想，为什么不让它成为静态的。因此，我认为我可以在 .NET 4.0 中利用 Lazy<T> 的使用，而不是使用 double checked locking。调用昂贵的服务一次而不是多次。

所以，如果这是我的伪代码，我该如何更改它使用Lazy<T>。 对于这个悔恨的例子，我将使用File System 作为昂贵的 资源 因此，在这个示例中，每次请求调用该 ActionMethod 时，我都希望使用 Lazy 来保存该文件列表，而不是从目标路径获取所有文件。当然，这只是第一次调用。

下一个假设：如果内容发生更改，请不要担心。这里超出了范围。

public class FooController : Controller
{
    private readonly IFoo _foo;
    public FooController(IFoo foo)
    {
        _foo = foo;
    }

    public ActionResult PewPew()
    {
        // Grab all the files in a folder.
        // nb. _foo.PathToFiles = "/Content/Images/Harro"
        var files = Directory.GetFiles(Server.MapPath(_foo.PathToFiles));

        // Note: No, I wouldn't return all the files but a concerete view model
        //       with only the data from a File object, I require.
        return View(files);
    }
}

Answer 1

在您的示例中，Directory.GetFiles 的结果取决于_foo 的值，这不是静态的。因此，您不能使用 Lazy<string[]> 的静态实例作为控制器所有实例之间的共享缓存。

ConcurrentDictionary<TKey, TValue> 听起来更接近您想要的。

// Code not tested, blah blah blah...
public class FooController : Controller
{
    private static readonly ConcurrentDictionary<string, string[]> _cache
        = new ConcurrentDictionary<string, string[]>();

    private readonly IFoo _foo;
    public FooController(IFoo foo)
    {
        _foo = foo;
    }

    public ActionResult PewPew()
    {
        var files = _cache.GetOrAdd(Server.MapPath(_foo.PathToFiles), path => {
            return Directory.GetFiles(path);
        });

        return View(files);
    }
}

Answer 2

我同意 Greg 的观点，即 Lazy 在这里不合适。

您可以尝试使用 asp.net caching 来缓存文件夹的内容，使用 _foo.PathToFiles 作为您的密钥。这比 Lazy 有一个优势，您可以控制缓存的生命周期，因此它会每天或每周重新获取内容，而无需重新启动应用程序。

缓存对您的服务器也很友好，因为如果没有足够的内存来支持它，它会优雅地降级。

Answer 3

Lazy<T> 在您不确定是否需要该资源时效果最佳，因此仅在实际需要时才及时加载。 无论如何，该操作总是会加载资源，但是因为它很昂贵，您可能希望将其缓存在某个地方？你可以试试这样的：

public ActionResult PewPew()
{
    MyModel model;
    const string cacheKey = "resource";
    lock (controllerLock)
    {
        if (HttpRuntime.Cache[cacheKey] == null)
        {
            HttpRuntime.Cache.Insert(cacheKey, LoadExpensiveResource());
        }
        model = (MyModel) HttpRuntime.Cache[cacheKey];
    }

    return View(model);
}

Answer 4

我刚遇到你描述的同样问题，所以我创建了一个类 CachedLazy<T> -> 允许在控制器实例之间共享值，但与 ConcurrentDictionary 不同，它具有可选的定时到期和一次性创建。

/// <summary>
/// Provides a lazily initialised and HttpRuntime.Cache cached value.
/// </summary>
public class CachedLazy<T>
{
    private readonly Func<T> creator;

    /// <summary>
    /// Key value used to store the created value in HttpRuntime.Cache
    /// </summary>
    public string Key { get; private set; }

    /// <summary>
    /// Optional time span for expiration of the created value in HttpRuntime.Cache
    /// </summary>
    public TimeSpan? Expiry { get; private set; }

    /// <summary>
    /// Gets the lazily initialized or cached value of the current Cached instance.
    /// </summary>
    public T Value
    {
        get
        {
            var cache = HttpRuntime.Cache;

            var value = cache[Key];
            if (value == null)
            {
                lock (cache)
                {
                    // After acquiring lock, re-check that the value hasn't been created by another thread
                    value = cache[Key];
                    if (value == null)
                    {
                        value = creator();
                        if (Expiry.HasValue)
                            cache.Insert(Key, value, null, Cache.NoAbsoluteExpiration, Expiry.Value);
                        else
                            cache.Insert(Key, value);
                    }
                }
            }

            return (T)value;
        }
    }

    /// <summary>
    /// Initializes a new instance of the CachedLazy class. If lazy initialization occurs, the given
    /// function is used to get the value, which is then cached in the HttpRuntime.Cache for the 
    /// given time span.
    /// </summary>
    public CachedLazy(string key, Func<T> creator, TimeSpan? expiry = null)
    {
        this.Key = key;
        this.creator = creator;
        this.Expiry = expiry;
    }
}