public static ExpirationHint ReadExpHint(CompactReader reader)
{
ExpirationHintType expHint = ExpirationHintType.Parent;
expHint = (ExpirationHintType)reader.ReadInt16();
ExpirationHint tmpObj = null;
switch (expHint)
{
case ExpirationHintType.NULL:
return(null);
case ExpirationHintType.Parent:
tmpObj = (ExpirationHint)reader.ReadObject();
return((ExpirationHint)tmpObj);
case ExpirationHintType.FixedExpiration:
FixedExpiration fe = new FixedExpiration();
((ICompactSerializable)fe).Deserialize(reader);
return((ExpirationHint)fe);
case ExpirationHintType.IdleExpiration:
IdleExpiration ie = new IdleExpiration();
((ICompactSerializable)ie).Deserialize(reader);
return((ExpirationHint)ie);
default:
break;
}
return(null);
}
protected static void Construct(FixedExpiration expiration, DateTime absoluteTime)
{
if (expiration != null)
{
expiration._absoluteTime = AppUtil.DiffSeconds(absoluteTime);
expiration._milliseconds = AppUtil.DiffMilliseconds(absoluteTime);
}
}
public static FixedIdleExpiration Create(PoolManager poolManager, TimeSpan idleTime, DateTime absoluteTime)
{
var expiration = Create(poolManager);
Construct(expiration, FixedExpiration.Create(poolManager, absoluteTime), IdleExpiration.Create(poolManager, idleTime));
return(expiration);
}
public static ExpirationHint ReadExpHint(CompactReader reader, PoolManager poolManager)
{
ExpirationHintType expHint = ExpirationHintType.Parent;
expHint = (ExpirationHintType)reader.ReadInt16();
switch (expHint)
{
case ExpirationHintType.NULL:
return(null);
case ExpirationHintType.Parent:
return((ExpirationHint)reader.ReadObject());
case ExpirationHintType.FixedExpiration:
var fe = FixedExpiration.Create(poolManager);
fe.Deserialize(reader);
return(fe);
case ExpirationHintType.TTLExpiration:
var ttle = TTLExpiration.Create(poolManager);
((ICompactSerializable)ttle).Deserialize(reader);
return(ttle);
case ExpirationHintType.FixedIdleExpiration:
var fie = FixedIdleExpiration.Create(poolManager);
((ICompactSerializable)fie).Deserialize(reader);
return(fie);
#if !(DEVELOPMENT || CLIENT)
case ExpirationHintType.NodeExpiration:
var ne = NodeExpiration.Create(poolManager);
((ICompactSerializable)ne).Deserialize(reader);
return(ne);
#endif
case ExpirationHintType.IdleExpiration:
var ie = IdleExpiration.Create(poolManager);
((ICompactSerializable)ie).Deserialize(reader);
return(ie);
case ExpirationHintType.AggregateExpirationHint:
var aeh = AggregateExpirationHint.Create(poolManager);
((ICompactSerializable)aeh).Deserialize(reader);
return(aeh);
case ExpirationHintType.DependencyHint:
break;
default:
break;
}
return(null);
}
public static ExpirationHint GetExpirationHint(DateTime absoluteExpiration, TimeSpan slidingExpiration)
{
ExpirationHint hint = null;
if (DateTime.MaxValue.ToUniversalTime().Equals(absoluteExpiration) && TimeSpan.Zero.Equals(slidingExpiration))
return null;
if (DateTime.MaxValue.ToUniversalTime().Equals(absoluteExpiration))
hint = new IdleExpiration(slidingExpiration);
else
{
absoluteExpiration = absoluteExpiration.ToUniversalTime();
hint = new FixedExpiration(absoluteExpiration);
}
return hint;
}
public static ExpirationHint GetExpirationHint(DateTime absoluteExpiration, TimeSpan slidingExpiration)
{
ExpirationHint hint = null;
if (DateTime.MaxValue.ToUniversalTime().Equals(absoluteExpiration) && TimeSpan.Zero.Equals(slidingExpiration))
{
return(null);
}
if (DateTime.MaxValue.ToUniversalTime().Equals(absoluteExpiration))
{
hint = new IdleExpiration(slidingExpiration);
}
else
{
absoluteExpiration = absoluteExpiration.ToUniversalTime();
hint = new FixedExpiration(absoluteExpiration);
}
return(hint);
}
private static ExpirationHint GetExpirationHint(PoolManager poolManager, DateTime absoluteExpiration, TimeSpan slidingExpiration)
{
ExpirationHint hint = null;
if (ExpirationConstants.AbsoluteNoneExpiration.ToUniversalTime().Equals(absoluteExpiration) && ExpirationConstants.SlidingNoneExpiration.Equals(slidingExpiration))
{
return(null);
}
if (!ExpirationConstants.AbsoluteNoneExpiration.ToUniversalTime().Equals(absoluteExpiration.ToUniversalTime()))
{
absoluteExpiration = absoluteExpiration.ToUniversalTime();
hint = FixedExpiration.Create(poolManager, absoluteExpiration);
}
else if (!ExpirationConstants.SlidingNoneExpiration.Equals(slidingExpiration))
{
hint = IdleExpiration.Create(poolManager, slidingExpiration);
}
return(hint);
}
public static ExpirationHint GetExpirationHintObj(long absoluteExpiration, long slidingExpiration, string serializationContext)
{
ExpirationHint hint = null;
//We expect Web.Cache to send in UTC DateTime, AbsoluteExpiration is dealt in UTC
if (absoluteExpiration != 0 && absoluteExpiration != DateTime.MaxValue.ToUniversalTime().Ticks) hint = new FixedExpiration(new DateTime(absoluteExpiration, DateTimeKind.Utc));
if (slidingExpiration != 0) hint = new IdleExpiration(new TimeSpan(slidingExpiration));
return hint;
}
private static ExpirationHint GetExpirationHint(ExpirationPolicy policy, DateTime absoluteExpiration, TimeSpan slidingExpiration)
{
ExpirationHint hint = null;
if (policy.SlidingExpiration.LongerEnabled || policy.SlidingExpiration.DefaultEnabled || policy.AbsoluteExpiration.LongerEnabled || policy.AbsoluteExpiration.DefaultEnabled)
{
if ((absoluteExpiration == AbsoluteDefaultExpiration.ToUniversalTime() || absoluteExpiration == AbsoluteLongerExpiration.ToUniversalTime() || (slidingExpiration == SlidingDefaultExpiration || slidingExpiration == SlidingLongerExpiration)))
{
#region In case user provides sliding expiration as an enum
if (absoluteExpiration == DateTime.MaxValue)
{
if (slidingExpiration == SlidingLongerExpiration && policy.SlidingExpiration.LongerEnabled)
{
hint = new IdleExpiration(new TimeSpan(policy.SlidingExpiration.Longer * TICKS));
}
else if (slidingExpiration == SlidingDefaultExpiration && policy.SlidingExpiration.DefaultEnabled)
{
hint = new IdleExpiration(new TimeSpan(policy.SlidingExpiration.Default * TICKS));
}
}
#endregion
#region In case user provides absolute expiration as an enum
if (slidingExpiration == TimeSpan.Zero)
{
if (absoluteExpiration == AbsoluteLongerExpiration.ToUniversalTime() && policy.AbsoluteExpiration.LongerEnabled)// check if Longer is enabled in config
{
hint = new FixedExpiration(DateTime.Now.AddSeconds(policy.AbsoluteExpiration.Longer).ToUniversalTime());
}
else if (absoluteExpiration == AbsoluteDefaultExpiration.ToUniversalTime() && policy.AbsoluteExpiration.DefaultEnabled)
{
hint = new FixedExpiration(DateTime.Now.AddSeconds(policy.AbsoluteExpiration.Default).ToUniversalTime());
}
}
#endregion
// If no expirations were enabled we have to assign the default expiration
}
else
{
if (hint == null)
{
hint = new FixedExpiration(DateTime.Now.AddSeconds(policy.AbsoluteExpiration.Default).ToUniversalTime());
}
}
}
if (DateTime.MaxValue.ToUniversalTime().Equals(absoluteExpiration) && TimeSpan.Zero.Equals(slidingExpiration))
{
return(null);
}
if (DateTime.MaxValue.ToUniversalTime().Equals(absoluteExpiration))
{
hint = new IdleExpiration(slidingExpiration);
}
else
{
absoluteExpiration = absoluteExpiration.ToUniversalTime();
hint = new FixedExpiration(absoluteExpiration);
}
return(hint);
}
public static ExpirationHint ReadExpHint(CompactReader reader)
{
ExpirationHintType expHint = ExpirationHintType.Parent;
expHint = (ExpirationHintType)reader.ReadInt16();
ExpirationHint tmpObj = null;
switch (expHint)
{
case ExpirationHintType.NULL:
return(null);
case ExpirationHintType.Parent:
tmpObj = (ExpirationHint)reader.ReadObject();
return((ExpirationHint)tmpObj);
case ExpirationHintType.FixedExpiration:
FixedExpiration fe = new FixedExpiration();
((ICompactSerializable)fe).Deserialize(reader);
return((ExpirationHint)fe);
case ExpirationHintType.TTLExpiration:
TTLExpiration ttle = new TTLExpiration();
((ICompactSerializable)ttle).Deserialize(reader);
return((ExpirationHint)ttle);
case ExpirationHintType.TTLIdleExpiration:
TTLIdleExpiration ttlie = new TTLIdleExpiration();
((ICompactSerializable)ttlie).Deserialize(reader);
return((ExpirationHint)ttlie);
case ExpirationHintType.FixedIdleExpiration:
FixedIdleExpiration fie = new FixedIdleExpiration();
((ICompactSerializable)fie).Deserialize(reader);
return((ExpirationHint)fie);
case ExpirationHintType.FileDependency:
FileDependency fd = new FileDependency();
((ICompactSerializable)fd).Deserialize(reader);
return((ExpirationHint)fd);
case ExpirationHintType.KeyDependency:
KeyDependency kd = new KeyDependency();
((ICompactSerializable)kd).Deserialize(reader);
return((ExpirationHint)kd);
#if !(DEVELOPMENT || CLIENT)
case ExpirationHintType.NodeExpiration:
NodeExpiration ne = new NodeExpiration();
((ICompactSerializable)ne).Deserialize(reader);
return((ExpirationHint)ne);
#endif
case ExpirationHintType.Sql7CacheDependency:
Sql7CacheDependency s7cd = new Sql7CacheDependency();
((ICompactSerializable)s7cd).Deserialize(reader);
return((ExpirationHint)s7cd);
case ExpirationHintType.OleDbCacheDependency:
OleDbCacheDependency oledbDependency = new OleDbCacheDependency();
((ICompactSerializable)oledbDependency).Deserialize(reader);
return((ExpirationHint)oledbDependency);
case ExpirationHintType.SqlYukonCacheDependency:
SqlYukonCacheDependency sycd = new SqlYukonCacheDependency();
((ICompactSerializable)sycd).Deserialize(reader);
return((ExpirationHint)sycd);
case ExpirationHintType.OracleCacheDependency:
OracleCacheDependency orclcd = new OracleCacheDependency();
((ICompactSerializable)orclcd).Deserialize(reader);
return((ExpirationHint)orclcd);
case ExpirationHintType.IdleExpiration:
IdleExpiration ie = new IdleExpiration();
((ICompactSerializable)ie).Deserialize(reader);
return((ExpirationHint)ie);
case ExpirationHintType.AggregateExpirationHint:
AggregateExpirationHint aeh = new AggregateExpirationHint();
((ICompactSerializable)aeh).Deserialize(reader);
return((ExpirationHint)aeh);
case ExpirationHintType.DBCacheDependency:
DBCacheDependency dbcd = new DBCacheDependency();
((ICompactSerializable)dbcd).Deserialize(reader);
return((ExpirationHint)dbcd);
case ExpirationHintType.ExtensibleDependency:
ExtensibleDependency ed = new ExtensibleDependency();
ed = (ExtensibleDependency)reader.ReadObject();
return((ExpirationHint)ed);
case ExpirationHintType.NosDBCacheDependency:
NosDBCacheDependency nosDbd = new NosDBCacheDependency();
((ICompactSerializable)nosDbd).Deserialize(reader);
return(nosDbd);
case ExpirationHintType.DependencyHint:
break;
default:
break;
}
return(null);
}
public static ExpirationHint ReadExpHint(CompactReader reader)
{
ExpirationHintType expHint = ExpirationHintType.Parent;
expHint = (ExpirationHintType)reader.ReadInt16();
ExpirationHint tmpObj = null;
switch (expHint)
{
case ExpirationHintType.NULL:
return null;
case ExpirationHintType.Parent:
tmpObj = (ExpirationHint)reader.ReadObject();
return (ExpirationHint)tmpObj;
case ExpirationHintType.FixedExpiration:
FixedExpiration fe = new FixedExpiration();
((ICompactSerializable)fe).Deserialize(reader);
return (ExpirationHint)fe;
case ExpirationHintType.IdleExpiration:
IdleExpiration ie = new IdleExpiration();
((ICompactSerializable)ie).Deserialize(reader);
return (ExpirationHint)ie;
default:
break;
}
return null;
}
