Exemplo n.º 1
0
    public void IsExpiredTest()
    {
      string key = "key";
      object value = "value";
      var cachePolicy = new CachePolicy { AbsoluteExpiration = DateTimeOffset.Now.AddDays(1) };
      var cacheItem = new CacheItem(key, value, cachePolicy);
      bool hasExpiration = cacheItem.CanExpire();
      Assert.AreEqual(true, hasExpiration);
      bool isExpired = cacheItem.IsExpired();
      Assert.AreEqual(false, isExpired);

      TimeSpan expiration = TimeSpan.FromSeconds(2);

      cachePolicy = new CachePolicy { SlidingExpiration = expiration };
      cacheItem = new CacheItem(key, value, cachePolicy);
      hasExpiration = cacheItem.CanExpire();
      Assert.AreEqual(true, hasExpiration);
      isExpired = cacheItem.IsExpired();
      Assert.AreEqual(false, isExpired);

      Thread.Sleep(expiration);
      isExpired = cacheItem.IsExpired();
      Assert.AreEqual(true, isExpired);

      cachePolicy = new CachePolicy { AbsoluteExpiration = DateTimeOffset.Now.Add(expiration) };
      cacheItem = new CacheItem(key, value, cachePolicy);
      hasExpiration = cacheItem.CanExpire();
      Assert.AreEqual(true, hasExpiration);
      isExpired = cacheItem.IsExpired();
      Assert.AreEqual(false, isExpired);

      Thread.Sleep(expiration);
      isExpired = cacheItem.IsExpired();
      Assert.AreEqual(true, isExpired);
    }
Exemplo n.º 2
0
    public void CacheItemConstructorTest()
    {
      string key = "key";
      object value = "value";
      var cachePolicy = new CachePolicy();
      var cacheItem = new CacheItem(key, value, cachePolicy);

      Assert.IsNotNull(cacheItem);
      Assert.AreEqual("key", cacheItem.Key);
      Assert.AreEqual("value", cacheItem.Value);
      Assert.IsNotNull(cacheItem.CachePolicy);
      Assert.AreEqual(CacheManager.NoSlidingExpiration, cacheItem.CachePolicy.SlidingExpiration);
      Assert.AreEqual(CacheManager.InfiniteAbsoluteExpiration, cacheItem.CachePolicy.AbsoluteExpiration);
    }
Exemplo n.º 3
0
        /// <summary>
        /// Initializes a new <see cref="CacheItem"/> instance using the specified key and value for the cache entry.
        /// </summary>
        /// <param name="key">A unique identifier for a <see cref="CacheItem"/> entry.</param>
        /// <param name="value">The data for a <see cref="CacheItem"/> entry.</param>
        /// <param name="cachePolicy">An object that contains eviction details for the <see cref="CacheItem"/>.</param>
        public CacheItem(string key, object value, CachePolicy cachePolicy)
        {
            if (key == null)
                throw new ArgumentNullException("key");
            if (value == null)
                throw new ArgumentNullException("value");

            _key = key;
            Value = value;
            CachePolicy = cachePolicy ?? new CachePolicy();

            _created = DateTimeOffset.UtcNow;

            if (CachePolicy.SlidingExpiration > TimeSpan.Zero)
                _absoluteExpiration = Created + CachePolicy.SlidingExpiration;
            else
                _absoluteExpiration = CachePolicy.AbsoluteExpiration;
        }
Exemplo n.º 4
0
    public void HasExpirationTest()
    {
      string key = "key";
      object value = "value";
      var cachePolicy = new CachePolicy{ SlidingExpiration = TimeSpan.FromSeconds(30)};
      var cacheItem = new CacheItem(key, value, cachePolicy);
      bool hasExpiration = cacheItem.CanExpire();
      Assert.AreEqual(true, hasExpiration);
      
      cachePolicy = new CachePolicy();
      cacheItem = new CacheItem(key, value, cachePolicy);
      hasExpiration = cacheItem.CanExpire();
      Assert.AreEqual(false, hasExpiration);

      cachePolicy = new CachePolicy { AbsoluteExpiration = DateTimeOffset.Now.AddDays(1) };
      cacheItem = new CacheItem(key, value, cachePolicy);
      hasExpiration = cacheItem.CanExpire();
      Assert.AreEqual(true, hasExpiration);
    }
Exemplo n.º 5
0
    public void UpdateUsageTest()
    {
      string key = "key";
      object value = "value";
      TimeSpan expiration = TimeSpan.FromSeconds(2);

      var cachePolicy = new CachePolicy { SlidingExpiration = expiration };
      var cacheItem = new CacheItem(key, value, cachePolicy);
      
      bool hasExpiration = cacheItem.CanExpire();
      Assert.AreEqual(true, hasExpiration);
      bool isExpired = cacheItem.IsExpired();
      Assert.AreEqual(false, isExpired);

      Thread.Sleep(TimeSpan.FromSeconds(1));
      cacheItem.UpdateUsage();

      isExpired = cacheItem.IsExpired();
      Assert.AreEqual(false, isExpired);

      Thread.Sleep(expiration);
      isExpired = cacheItem.IsExpired();
      Assert.AreEqual(true, isExpired);
      
      cacheItem.UpdateUsage();
      isExpired = cacheItem.IsExpired();
      Assert.AreEqual(false, isExpired);
    }
Exemplo n.º 6
0
    public void RaiseExpiredCallbackTest()
    {
      string key = "key";
      object value = "value";
      TimeSpan expiration = TimeSpan.FromSeconds(2);
      bool expireCalled = false;

      var cachePolicy = new CachePolicy
      {
        SlidingExpiration = expiration,
        ExpiredCallback = e => { expireCalled = true; }
      };
      var cacheItem = new CacheItem(key, value, cachePolicy);
      bool hasExpiration = cacheItem.CanExpire();
      Assert.AreEqual(true, hasExpiration);
      bool isExpired = cacheItem.IsExpired();
      Assert.AreEqual(false, isExpired);

      Thread.Sleep(expiration);
      isExpired = cacheItem.IsExpired();
      Assert.AreEqual(true, isExpired);

      cacheItem.RaiseExpiredCallback();
      Thread.Sleep(expiration);

      Assert.AreEqual(true, expireCalled);

    }
    public void UpdatePolicyTest()
    {
      var cacheManager = new CacheManager();
      string key = "key" + DateTime.Now.Ticks;
      object value = "value" + DateTime.Now.Ticks;
      TimeSpan expiration = TimeSpan.FromSeconds(2);

      DateTimeOffset absoluteExpiration = DateTimeOffset.Now.Add(expiration);

      var cachePolicy = new CachePolicy { AbsoluteExpiration = absoluteExpiration };

      bool isAdded = cacheManager.Add(key, value, cachePolicy);
      Assert.AreEqual(true, isAdded);
      bool contains = cacheManager.Contains(key);
      Assert.AreEqual(true, contains);

      var cacheItem = cacheManager.GetCacheItem(key);
      Assert.IsNotNull(cacheItem);
      Assert.AreEqual(absoluteExpiration, cacheItem.AbsoluteExpiration);

      DateTimeOffset newExpiration = DateTimeOffset.Now.AddMinutes(20);
      var newPolicy = new CachePolicy { AbsoluteExpiration = newExpiration };

      cacheManager.Set(key, value, newPolicy);

      var newItem = cacheManager.GetCacheItem(key);

      Assert.IsNotNull(newItem);
      Assert.AreEqual(newExpiration, newItem.AbsoluteExpiration);


    }
    public void ExpireItemTest()
    {
      var cacheManager = new CacheManager();
      string key = "key" + DateTime.Now.Ticks;
      object value = "value" + DateTime.Now.Ticks;
      TimeSpan expiration = TimeSpan.FromSeconds(2);
      
      var cachePolicy = new CachePolicy { AbsoluteExpiration = DateTimeOffset.Now.Add(expiration) };
      
      bool isAdded = cacheManager.Add(key, value, cachePolicy);
      Assert.AreEqual(true, isAdded);
      bool contains = cacheManager.Contains(key);
      Assert.AreEqual(true, contains);
      
      // waited for exiration timer
      Thread.Sleep(TimeSpan.FromSeconds(22));
      contains = cacheManager.Contains(key);
      Assert.AreEqual(false, contains);
      Assert.AreEqual(0, cacheManager.Count);

      cachePolicy = new CachePolicy { SlidingExpiration = expiration };
      isAdded = cacheManager.Add(key, value, cachePolicy);
      Assert.AreEqual(true, isAdded);
      contains = cacheManager.Contains(key);
      Assert.AreEqual(true, contains);

      // waited for exiration timer
      Thread.Sleep(TimeSpan.FromSeconds(22));
      contains = cacheManager.Contains(key);
      Assert.AreEqual(false, contains);
      Assert.AreEqual(0, cacheManager.Count);

    }
Exemplo n.º 9
0
        /// <summary>
        /// Updates the <see cref="CachePolicy"/> for this <see cref="CacheItem"/>.
        /// </summary>
        /// <param name="cachePolicy">The cache policy.</param>
        internal void UpdatePolicy(CachePolicy cachePolicy)
        {
            CachePolicy = cachePolicy ?? new CachePolicy();

            _lastUpdateUsage = DateTimeOffset.UtcNow;

            if (CachePolicy.SlidingExpiration > TimeSpan.Zero)
                _absoluteExpiration = LastUpdateUsage + CachePolicy.SlidingExpiration;
            else
                _absoluteExpiration = CachePolicy.AbsoluteExpiration.UtcDateTime;
        }