懒惰有过期时间

2021 年编辑：

您可能不应该使用此代码。也许对于一个非常简单的应用程序来说已经足够了，但它有一些问题。它不支持缓存失效，由于它使用 DateTime 的方式，它可能会遇到与 DST 或其他时区更改相关的问题，并且它以安全但可能非常慢的方式使用锁。考虑改用类似 MemoryCache 的东西。

原答案：

我同意其他评论者的观点，您可能根本不应该碰懒惰。如果您忽略多个线程安全选项，Lazy 并不是很复杂，因此只需从头开始实现它即可。

顺便说一下，我非常喜欢这个想法，尽管我不知道我是否愿意将其用作通用缓存策略。对于一些更简单的方案，这可能就足够了。

这是我的刺痛。如果你不需要它是线程安全的，你可以删除锁定的东西。我认为不可能在这里使用双重检查锁定模式，因为缓存的值可能会在锁内失效。

public class Temporary<T>
{
    private readonly Func<T> factory;
    private readonly TimeSpan lifetime;
    private readonly object valueLock = new object();
    private T value;
    private bool hasValue;
    private DateTime creationTime;
    
    public Temporary(Func<T> factory, TimeSpan lifetime)
    {
        this.factory = factory;
        this.lifetime = lifetime;
    }
    
    public T Value
    {
        get
        {
            DateTime now = DateTime.Now;
            lock (this.valueLock)
            {
                if (this.hasValue)
                {
                    if (this.creationTime.Add(this.lifetime) < now)
                    {
                        this.hasValue = false;
                    }
                }
                
                if (!this.hasValue)
                {
                    this.value = this.factory();
                    this.hasValue = true;
                    // You can also use the existing "now" variable here.
                    // It depends on when you want the cache time to start
                    // counting from.
                    this.creationTime = Datetime.Now;
                }
                
                return this.value;
            }
        }
    }
}

认为Lazy<T>在这里会有任何影响，它更像是一种通用方法，本质上类似于单例模式。

你需要一个简单的包装类，它将返回真实对象或将所有调用传递给它。

我会尝试这样的事情（内存不足，所以可能包含错误）：

public class Timed<T> where T : new() {
    DateTime init;
    T obj;
    public Timed() {
        init = new DateTime(0);
    }
    public T get() {
        if (DateTime.Now - init > max_lifetime) {
            obj = new T();
            init = DateTime.Now;
        }
        return obj;
    }
}

要使用，您只需使用 Timed<MyClass> obj = new Timed<MyClass>(); 而不是 MyClass obj = new MyClass(); .实际呼叫将obj.get().doSomething()而不是obj.doSomething().

编辑：

请注意，您不必将类似于我上面的方法与Lazy<T>相结合，因为您实际上已经强制延迟初始化。例如，您当然可以在构造函数中定义最大生存期。

我需要同样的东西。但是当没有写入时，我更喜欢没有锁定读取的实现。

public class ExpiringLazy<T>
{
    private readonly Func<T> factory;
    private readonly TimeSpan lifetime;
    private readonly ReaderWriterLockSlim locking = new ReaderWriterLockSlim(LockRecursionPolicy.NoRecursion);
    private T value;
    private DateTime expiresOn = DateTime.MinValue;
    public ExpiringLazy(Func<T> factory, TimeSpan lifetime)
    {
        this.factory = factory;
        this.lifetime = lifetime;
    }
    public T Value
    {
        get
        {
            DateTime now = DateTime.UtcNow;
            locking.EnterUpgradeableReadLock();
            try
            {
                if (expiresOn < now)
                {
                    locking.EnterWriteLock();
                    try
                    {
                        if (expiresOn < now)
                        {
                            value = factory();
                            expiresOn = DateTime.UtcNow.Add(lifetime);
                        }
                    }
                    finally
                    {
                        locking.ExitWriteLock();
                    }
                }
                return value;
            }
            finally
            {
                locking.ExitUpgradeableReadLock();
            }
        }
    }
}