具有过期时间的Lazy<T>

Question

我希望在Lazy对象上实现一个过期时间。过期冷却时间必须从第一次检索该值开始计算。如果我们获取了该值，但已经过期，则重新执行该函数并重置过期时间。

我不熟悉扩展、partial关键字，并且不知道最佳实现方式。

谢谢！

编辑：

到目前为止的代码：

新编辑：

新代码：

public class LazyWithExpiration<T>
{
    private volatile bool expired;
    private TimeSpan expirationTime;
    private Func<T> func;
    private Lazy<T> lazyObject;

    public LazyWithExpiration( Func<T> func, TimeSpan expirationTime )
    {
        this.expirationTime = expirationTime;
        this.func = func;

        Reset();
    }

    public void Reset()
    {
        lazyObject = new Lazy<T>( func );
        expired = false;
    }

    public T Value
    {
        get
        {
            if ( expired )
                Reset();

            if ( !lazyObject.IsValueCreated )
            {
                Task.Factory.StartNew( () =>
                {
                    Thread.Sleep( expirationTime );
                    expired = true;
                } );
            }

            return lazyObject.Value;
        }
    }

}

- Bastiflew

---

请展示你目前实现懒加载的代码。SO并不是我们为你编写所有代码的地方...请展示你迄今为止尝试过的内容。 - Hogan

扩展和部分关键字在这里不会有帮助。我会为Lazy<T>创建一个包装类（虽然可能有更优雅的解决方案）。 - Omada

我同意这是一个简单的问题，只需用代码包装访问器并检查计时器是否已过期即可。我认为不需要使用Lazy<T>，但这取决于上下文，所以请展示一下目前的代码。 - Hogan

你正在试图强制将一些新行为加入到Lazy<T>类中，这是行不通的（你必须修改它的基本行为）。最好创建自己的包装器，然后在需要延迟初始化时在其中使用。如果你正在使用我在答案中使用的那个（或类似的方法），你根本不需要Lazy<T>，因为它已经模仿了它的行为。 - Mario

@Mario：我认为你是对的，我最好创建一个包含Lazy<T>的自己的包装器。 - Bastiflew

Answer 1

2021编辑：

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

原始回答：

我同意其他评论者的观点，您可能根本不应该碰Lazy。如果您忽略多个线程安全选项，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;
            }
        }
    }
}

- Magnus Grindal Bakken

---

在2021年，这仍然是最好的做法吗？我发现这个类非常有用，但答案相当古老，所以如果已经被纳入到.NET或其他东西中，那就很好了解。 - Craig

@Craig 如果你的目标是为了缓存值以节省计算时间，那么最好使用System.Runtime.Caching中的MemoryCache或其他缓存库。我回答中的代码可能存在时区和时钟同步的潜在问题，并且没有办法使缓存的值失效。 - Magnus Grindal Bakken

不要使用 DateTime.Now，夏令时会给你带来麻烦。 :) 你的代码中还有一些拼写错误。 - mjwills

内存缓存是我一直在寻找的，谢谢。 - Craig

Answer 2

我认为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>，因为您已经强制进行了延迟初始化。当然，您可以在构造函数中定义最大生命周期。

- Mario

---

我认为在这种情况下，你需要限制T为where T : new()。 - Omada

嗯，不太确定。我不认为我曾经在C#中使用过泛型。编辑：是的，看起来你是对的。 - Mario

此外，“return object”是编译错误。你是想说“return init”对吧？而且使用属性的话，“get”更加合适。效果是一样的，但用这种方式更符合惯用法。 - siride

就此而言，“void”参数列表在C#中也是无效的。 - Trillian

“return object” 是一个遗留问题，一开始忘记了内置类型并忘记更改那行代码。是的，“void”没错。至于getter...该怎么命名呢？但是，有很多不同的方法。您也可以跳过整个“get()”，只需使用一些预定义接口来包装所有成员即可。 - Mario

Answer 3

我也需要同样的东西。但是我更喜欢在没有写入时不使用锁定读取的实现方式。

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();
            }
        }
    }
}

- Pietro