Lazy <T> с истечением срока действия

Я хочу реализовать время истечения срока действия объекта Lazy. Кулдаун истечения срока действия должен начинаться с первого извлечения значения. Если мы получим значение и время истечения будет передано, мы повторно выполним функцию и reset время истечения срока действия.

Я не знаком с расширениями, частичным ключевым словом, и я не знаю, как это сделать.

Спасибо

ИЗМЕНИТЬ:

Код до сих пор:

NEW EDIT:

новый код:

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

}

Ответ 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().

Edit:

Просто обратите внимание, что вам не придется сочетать подход, подобный моему выше, с Lazy<T>, потому что вы по существу вынуждаете задержку инициализации. Разумеется, вы, конечно, можете определить максимальное время жизни в конструкторе.

Ответ 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;
            }
        }
    }
}

Ответ 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();
            }
        }
    }
}