/// <summary>
/// Cria a instancia com os valores iniciais.
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
/// <param name="dependency"></param>
/// <param name="syncDependency"></param>
/// <param name="expiration"></param>
/// <param name="options"></param>
/// <param name="itemRemovedCallback"></param>
/// <param name="group"></param>
/// <param name="subgroup"></param>
/// <param name="queryInfo"></param>
/// <param name="Flag"></param>
/// <param name="lockId"></param>
/// <param name="version"></param>
/// <param name="accessType"></param>
/// <param name="providername"></param>
/// <param name="resyncProviderName"></param>
public CompactCacheEntry(object key, object value, ExpirationHint dependency, CacheSyncDependency syncDependency, long expiration, byte options, object itemRemovedCallback, string group, string subgroup, Hashtable queryInfo, BitSet Flag, object lockId, ulong version, LockAccessType accessType, string providername, string resyncProviderName)
{
_key = key;
_flag = Flag;
_value = value;
_dependency = dependency;
_syncDependency = syncDependency;
_expiration = expiration;
_options = options;
_itemRemovedCallback = itemRemovedCallback;
if (group != null)
{
_group = group;
if (subgroup != null)
{
_subgroup = subgroup;
}
}
_queryInfo = queryInfo;
_lockId = lockId;
_accessType = accessType;
_version = version;
_providerName = providername;
_resyncProviderName = resyncProviderName;
}
void ICompactSerializable.Deserialize(CompactReader reader)
{
lock (this)
{
Value = reader.ReadObject();
_bitset = new BitSet(reader.ReadByte());
_evh = EvictionHint.ReadEvcHint(reader);
_exh = ExpirationHint.ReadExpHint(reader);
_grpInfo = GroupInfo.ReadGrpInfo(reader);
_syncDependency = reader.ReadObject() as CacheSyncDependency;
_queryInfo = (Hashtable)reader.ReadObject();
_keysDependingOnMe = (HashVector)reader.ReadObject();
_size = reader.ReadInt64();
lockMetaInfo = reader.ReadObject() as LockMetaInfo;
_version = reader.ReadUInt64();
_creationTime = reader.ReadDateTime();
_lastModifiedTime = reader.ReadDateTime();
ResyncProviderName = reader.ReadObject() as string;
_priorityValue = (CacheItemPriority)reader.ReadInt32();
ProviderName = reader.ReadObject() as string;
_type = reader.ReadObject() as string;
_itemUpdateListener = reader.ReadObject() as ArrayList;
_itemRemovedListener = reader.ReadObject() as ArrayList;
}
}
/// <summary>
/// Construtor padrão.
/// </summary>
/// <param name="cache">Instancia do cache onde a entrada será adicionada.</param>
/// <param name="key">Chave da entrada.</param>
/// <param name="value">Valor da entrada.</param>
/// <param name="expiryHint">Hint de expiração.</param>
/// <param name="syncDependency">Dependencia de sincronização.</param>
/// <param name="evictionHint">Hint de liberação</param>
/// <param name="group"></param>
/// <param name="subGroup"></param>
/// <param name="Flag"></param>
/// <param name="queryInfo"></param>
/// <param name="operationContext"></param>
public AsyncAdd(Cache cache, object key, object value, ExpirationHint expiryHint, CacheSyncDependency syncDependency, EvictionHint evictionHint, string group, string subGroup, BitSet Flag, Hashtable queryInfo, OperationContext operationContext)
{
_cache = cache;
_key = key;
_value = value;
_expiryHint = expiryHint;
_syncDependency = syncDependency;
_evictionHint = evictionHint;
_group = group;
_subGroup = subGroup;
_flag = Flag;
_queryInfo = queryInfo;
_operationContext = operationContext;
}
protected CacheSyncDependency GetCacheSyncDependencyObj(Alachisoft.NCache.Common.Protobuf.SyncDependency protocolSyncDependency)
{
if (protocolSyncDependency == null)
{
return(null);
}
SyncCache syncCache = new SyncCache(protocolSyncDependency.cacheId,
protocolSyncDependency.server,
protocolSyncDependency.port, false);
CacheSyncDependency syncDep = new CacheSyncDependency(protocolSyncDependency.cacheId,
protocolSyncDependency.key,
syncCache);
return(syncDep);
}
public APILogItem(string key, CacheItem item, string exceptionMessage)
{
_key = key;
_group = item.Group;
_subGroup = item.SubGroup;
_tags = item.Tags;
_namedTags = item.NamedTags;
_abs = item.AbsoluteExpiration;
_sld = item.SlidingExpiration;
_p = item.Priority;
_dep = item.Dependency;
_syncDep = item.SyncDependency;
_resyncProviderName = item.ResyncProviderName;
_version = item.Version;
_isResyncRequired = item.IsResyncExpiredItems;
this.ExceptionMessage = exceptionMessage;
}
/// <summary>
/// Adiciona uma dependencia de sincronização para o item associado com a chave informada.
/// </summary>
/// <param name="key">Chave do item do cache.</param>
/// <param name="syncDependency">Instancia da dependencia de sincronização.</param>
/// <returns>True caso a operação tenha sido executada com sucesso.</returns>
internal override bool AddInternal(object key, CacheSyncDependency syncDependency)
{
if (_cacheStore == null)
{
throw new InvalidOperationException();
}
CacheEntry item = (CacheEntry)_cacheStore.Get(key);
if (item == null)
{
return(false);
}
item.SyncDependency = syncDependency;
_cacheStore.Insert(key, item);
item.LastModifiedTime = DateTime.Now;
return(true);
}
public AddSyncDependencyCommand(string key, CacheSyncDependency syncDependency, int methodOverload)
{
base.name = "AddSyncDependencyCommand";
_addSyncDependencyCommand = new Alachisoft.NCache.Common.Protobuf.AddSyncDependencyCommand();
_addSyncDependencyCommand.key = key;
_addSyncDependencyCommand.requestId = base.RequestId;
if (syncDependency != null)
{
_addSyncDependencyCommand.syncDependency = new Alachisoft.NCache.Common.Protobuf.SyncDependency();
_addSyncDependencyCommand.syncDependency.key = syncDependency.Key;
_addSyncDependencyCommand.syncDependency.cacheId = syncDependency.CacheId;
_addSyncDependencyCommand.syncDependency.server = syncDependency.Server;
_addSyncDependencyCommand.syncDependency.port = syncDependency.Port;
}
_methodOverload = methodOverload;
}
internal AddCommand(string key, byte[] value, CacheDependency dependency, CacheSyncDependency syncDependency,
DateTime absoluteExpiration, TimeSpan slidingExpiration, CacheItemPriority priority, short removeCallback,
short updateCallback, short dsItemAddedCallback, bool isResyncExpiredItems, string group, string subGroup,
short itemAdded, bool isAsync, Hashtable queryInfo, BitSet flagMap, string providerName,
string resyncProviderName, string cacheId, EventDataFilter updateDataFilter,
EventDataFilter removeDataFilter, int methodOverload, string clientId)
{
base.name = "AddCommand";
base.asyncCallbackSpecified = isAsync && itemAdded != -1 ? true : false;
base.isAsync = isAsync;
base.key = key;
_itemAdded = itemAdded;
_addCommand = new Alachisoft.NCache.Common.Protobuf.AddCommand();
if (absoluteExpiration.Equals(Caching.Cache.DefaultAbsolute.ToUniversalTime()))
{
_addCommand.absExpiration = 1;
}
else if (absoluteExpiration.Equals(Caching.Cache.DefaultAbsoluteLonger.ToUniversalTime()))
{
_addCommand.absExpiration = 2;
}
else if (absoluteExpiration != Caching.Cache.NoAbsoluteExpiration)
{
_addCommand.absExpiration = absoluteExpiration.Ticks;
}
if (slidingExpiration.Equals(Caching.Cache.DefaultSliding))
{
_addCommand.sldExpiration = 1;
}
else if (slidingExpiration.Equals(Caching.Cache.DefaultSlidingLonger))
{
_addCommand.sldExpiration = 2;
}
else if (slidingExpiration != Caching.Cache.NoSlidingExpiration)
{
_addCommand.sldExpiration = slidingExpiration.Ticks;
}
Alachisoft.NCache.Caching.UserBinaryObject ubObject =
Alachisoft.NCache.Caching.UserBinaryObject.CreateUserBinaryObject(value);
_addCommand.key = key;
_addCommand.data.AddRange(ubObject.DataList);
_addCommand.requestId = base.RequestId;
_addCommand.updateCallbackId = updateCallback;
_addCommand.removeCallbackId = removeCallback;
_addCommand.datasourceItemAddedCallbackId = dsItemAddedCallback;
_addCommand.isAsync = isAsync;
_addCommand.priority = (int)priority;
_addCommand.isResync = isResyncExpiredItems;
_addCommand.group = group;
_addCommand.subGroup = subGroup;
_addCommand.flag = flagMap.Data;
_addCommand.providerName = providerName;
_addCommand.resyncProviderName = resyncProviderName;
_addCommand.updateDataFilter = (short)updateDataFilter;
_addCommand.removeDataFilter = (short)removeDataFilter;
_addCommand.clientID = clientId;
if (syncDependency != null)
{
_addCommand.syncDependency = new SyncDependency();
_addCommand.syncDependency.cacheId = syncDependency.CacheId;
_addCommand.syncDependency.key = syncDependency.Key;
_addCommand.syncDependency.server = syncDependency.Server;
_addCommand.syncDependency.port = syncDependency.Port;
}
ObjectQueryInfo objectQueryInfo = new ObjectQueryInfo();
if (queryInfo["query-info"] != null)
{
objectQueryInfo.queryInfo = ProtobufHelper.GetQueryInfoObj(queryInfo["query-info"] as Hashtable);
}
if (queryInfo["tag-info"] != null)
{
objectQueryInfo.tagInfo = ProtobufHelper.GetTagInfoObj(queryInfo["tag-info"] as Hashtable);
}
if (queryInfo["named-tag-info"] != null)
{
objectQueryInfo.namedTagInfo =
ProtobufHelper.GetNamedTagInfoObj(queryInfo["named-tag-info"] as Hashtable, true);
}
_addCommand.objectQueryInfo = objectQueryInfo;
if (dependency != null)
{
_addCommand.dependency =
Alachisoft.NCache.Common.Util.DependencyHelper.GetProtoBufDependency(dependency);
}
_methodOverload = methodOverload;
}
public override bool Add(object key, CacheSyncDependency syncDependency, OperationContext operationContext)
{
return(this.Internal.Add(key, syncDependency, operationContext));
}
