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);
}
internal OracleDependencyListener(string key, string connString, string queryString,
IDBConnectionPool connectionPool, IDependencyChangeListener dependencyListener, ILogger logger,
ExpirationHintType hintType, CommandType cmdType, IDictionary cmdParams)
: base(key, connString, queryString, connectionPool, dependencyListener, logger, hintType)
{
_cmdParams = cmdParams;
_cmdType = cmdType;
}
internal NosDBDependencyListener(string key, string connString, string queryString,
CacheRuntimeContext context, ExpirationHintType hintType, int timeOut = 0, IDictionary cmdParams = null)
: base(
key, connString, queryString, context.ExpiryMgr.NotifBasedDepManager,
context.ExpiryMgr.NotifBasedDepManager, context.NCacheLog, hintType)
{
_cmdParams = cmdParams;
_timeout = timeOut;
}
/// <summary>
/// Initialize instance of dependency listener
/// </summary>
/// <param name="key">key used to reference object</param>
/// <param name="connString">connection string used to connect database</param>
/// <param name="queryString">query string for which dataset is created to be monitored</param>
/// <param name="context">current cache runtime context</param>
/// <param name="hintType">expiration hint type</param>
protected DependencyListener(string key, string connString, string queryString, IDBConnectionPool connectionPool, IDependencyChangeListener dependencyListener, ILogger logger, ExpirationHintType hintType)
{
_cacheKey = key;
_connString = connString;
_queryString = queryString;
_hintType = hintType;
_ncacheLog = logger;
_connectionPool = connectionPool;
_dependencyListener = dependencyListener;
}
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 DependencyListener Create(string key, string connString, string queryString,
IDBConnectionPool connectionPool, IDependencyChangeListener dependencyListener,
Alachisoft.NCache.Common.Logger.ILogger logger, ExpirationHintType hintType,
System.Data.CommandType cmdType, System.Collections.IDictionary cmdParams)
{
#if !NET20
return(new OracleDependencyListener(key, connString, queryString, connectionPool, dependencyListener,
logger, hintType, cmdType, cmdParams));
#else
return(null);
#endif
}
/// <summary>
/// Create and initialize dependency listener and Add it to the listener list and
/// </summary>
/// <param name="key">key used to reference object</param>
/// <param name="connString">connection string used to connect to database</param>
/// <param name="queryString">query string for which dataset is created to be monitored</param>
/// <param name="doInitialize"></param>
/// <param name="hintType"></param>
/// <returns></returns>
public bool Add(string key, string connString, string queryString, bool doInitialize, ExpirationHintType hintType)
{
DependencyListener listener = null;
if (hintType == ExpirationHintType.OracleCacheDependency)
{
#if NET40
string fullAssemblyName = "Alachisoft.NCache.RuntimeDependencies, Version=" + Assembly.GetExecutingAssembly().GetName().Version;
System.Reflection.Assembly assembly = System.Reflection.Assembly.Load(fullAssemblyName);
Type factoryType = assembly.GetType("Alachisoft.NCache.RuntimeDependencies.DependencyListenerFactory");
Object[] oDLArgs = new Object[7];
oDLArgs[0] = key;
oDLArgs[1] = connString;
oDLArgs[2] = queryString;
oDLArgs[3] = this;
oDLArgs[4] = this;
oDLArgs[5] = _context.NCacheLog;
oDLArgs[6] = hintType;
Object dLFactory = Activator.CreateInstance(factoryType);
MethodInfo dLFactoryCreateMethod = factoryType.GetMethod("Create");
listener = (DependencyListener)(dLFactoryCreateMethod.Invoke(dLFactory, oDLArgs));
#else
return(true);
#endif
}
else if (hintType == ExpirationHintType.SqlYukonCacheDependency)
{
if (hintType == ExpirationHintType.SqlYukonCacheDependency)
{
listener = new YukonDependencyListener(key, connString, queryString, _context, hintType);
}
else if (hintType == ExpirationHintType.NosDBCacheDependency)
{
listener = new NosDBDependencyListener(key, connString, queryString, _context, hintType);
}
}
if (doInitialize)
{
listener.Initialize();
lock (_listeners.SyncRoot)
{
if (!_listeners.Contains(listener.CacheKey))
{
ArrayList _dblistner = new ArrayList();
_dblistner.Add(listener);
_listeners[listener.CacheKey] = _dblistner;
}
else
{
ArrayList _dblistner = (ArrayList)_listeners[listener.CacheKey];
_dblistner.Add(listener);
_listeners[listener.CacheKey] = _dblistner;
}
}
}
else
{
lock (_silentListeners.SyncRoot)
{
_silentListeners[listener.CacheKey] = listener;
}
}
return(true);
}
internal YukonDependencyListener(string key, string connString, string queryString, CacheRuntimeContext context, ExpirationHintType hintType, CommandType cmdType, IDictionary cmdParams)
: base(key, connString, queryString, context.ExpiryMgr.NotifBasedDepManager, context.ExpiryMgr.NotifBasedDepManager, context.NCacheLog, hintType)
{
_cmdParams = cmdParams;
_cmdType = cmdType;
_context = context;
_notifBasedDepManager = _context.ExpiryMgr.NotifBasedDepManager;
}
/// <summary>
/// Initialize instance of oracle dependency listener
/// </summary>
/// <param name="key">key used to reference object</param>
/// <param name="connString">connection string used to connect database</param>
/// <param name="queryString">query string for which dataset is created to be monitored</param>
/// <param name="context">current cache runtime context</param>
/// <param name="hintType">expiration hint type</param>
internal YukonDependencyListener(string key, string connString, string queryString, CacheRuntimeContext context, ExpirationHintType hintType)
: this(key, connString, queryString, context, hintType, CommandType.Text, null)
{
}
protected ExpirationHint()
{
_hintType = ExpirationHintType.Parent;
}
public void Deserialize(CompactReader reader)
{
this._hintType = (ExpirationHintType)reader.ReadObject();
this._bits = reader.ReadInt32();
}
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);
}
/// <summary>
/// Deserializa os dados para a instancia.
/// </summary>
/// <param name="reader"></param>
public virtual void Deserialize(CompactReader reader)
{
HintType = (ExpirationHintType)reader.ReadObject();
_bits = reader.ReadInt32();
}
public static ExpirationHint ReadExpHint(CompactReader reader)
{
ExpirationHintType parent = ExpirationHintType.Parent;
parent = (ExpirationHintType)reader.ReadInt16();
switch (parent)
{
case ExpirationHintType.NULL:
return(null);
case ExpirationHintType.Parent:
return((ExpirationHint)reader.ReadObject());
case ExpirationHintType.FixedExpiration:
{
FixedExpiration expiration = new FixedExpiration();
expiration.Deserialize(reader);
return(expiration);
}
case ExpirationHintType.FixedIdleExpiration:
{
FixedIdleExpiration expiration4 = new FixedIdleExpiration();
expiration4.Deserialize(reader);
return(expiration4);
}
case ExpirationHintType.FileDependency:
{
FileDependency dependency = new FileDependency();
dependency.Deserialize(reader);
return(dependency);
}
case ExpirationHintType.KeyDependency:
{
KeyDependency dependency2 = new KeyDependency();
dependency2.Deserialize(reader);
return(dependency2);
}
case ExpirationHintType.IdleExpiration:
{
IdleExpiration expiration5 = new IdleExpiration();
expiration5.Deserialize(reader);
return(expiration5);
}
case ExpirationHintType.AggregateExpirationHint:
{
AggregateExpirationHint hint2 = new AggregateExpirationHint();
hint2.Deserialize(reader);
return(hint2);
}
case ExpirationHintType.ExtensibleDependency:
{
ExtensibleDependency dependency8 = new ExtensibleDependency();
return((ExtensibleDependency)reader.ReadObject());
}
}
return(null);
}
/// <summary>
/// Initialize instance of oracle dependency listener
/// </summary>
/// <param name="key">key used to reference object</param>
/// <param name="connString">connection string used to connect database</param>
/// <param name="queryString">query string for which dataset is created to be monitored</param>
/// <param name="context">current cache runtime context</param>
/// <param name="hintType">expiration hint type</param>
internal OracleDependencyListener(string key, string connString, string queryString,
IDBConnectionPool connectionPool, IDependencyChangeListener dependencyListener, ILogger logger,
ExpirationHintType hintType)
: base(key, connString, queryString, connectionPool, dependencyListener, logger, hintType)
{
}
protected ExpirationHint()
{
_hintType = ExpirationHintType.Parent;
}
public void Deserialize(CompactReader reader)
{
this._hintType = (ExpirationHintType)reader.ReadObject();
this._bits = reader.ReadInt32();
}
