Question

我想在Lazy对象上实现过期时间。到期的冷却时间必须从第一次检索值开始。如果我们得到了值，并且过期时间已经过去，那么我们重新执行该函数并重置到期时间。

我不熟悉扩展程序，部分关键字，我不知道最好的方法。

由于

编辑：

到目前为止的代码：

新编辑：

新代码：

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

}

Answer 1

我认为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>结合使用，因为您已经基本上强制执行延迟初始化。当然，您可以在构造函数中定义最长生命周期。

Answer 2

我同意其他评论者的意见，你可能根本不应该触及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;
            }
        }
    }
}

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

延迟<t>，有效期</t>

3 个答案: