internal CacheEventArg(string key, string cachename, EventType eventType, EventCacheItem item,
CacheEventDescriptor discriptor, CacheItemRemovedReason reason)
: base(cachename, eventType, item)
{
_reason = reason;
_descriptor = discriptor;
}
public void OnCustomUpdateCallback(object key, object value, EventContext eventContext)
{
EventCacheItem item = EventUtil.ConvertToItem(eventContext.Item);
EventCacheItem oldItem = EventUtil.ConvertToItem(eventContext.OldItem);
_listener.OnCustomUpdateCallback((string)key, value, true, item, oldItem, null);
}
public void OnItemRemoved(object key, object value, ItemRemoveReason reason, BitSet Flag,
EventContext eventContext)
{
EventCacheItem item = null;
try
{
BitSet flag = new BitSet(0);
if (eventContext.Item != null)
{
item = EventUtil.ConvertToItem(eventContext.Item);
}
if (_listener != null)
{
_listener.OnItemRemoved((string)key,
value,
reason,
Flag, true, item);
}
}
catch
{
}
}
private CacheEventArg CreateCacheEventArgument(EventDataFilter dataFilter, string key, string cacheName, EventType eventType, EventCacheItem item, EventCacheItem oldItem, CacheItemRemovedReason removedReason)
{
EventCacheItem cloneItem = null;
EventCacheItem cloneOldItem = null;
if (dataFilter != EventDataFilter.None && item != null)
{
cloneItem = item.Clone() as EventCacheItem;
if (dataFilter == EventDataFilter.Metadata)
{
cloneItem.Value = null;
}
}
if (dataFilter != EventDataFilter.None && oldItem != null)
{
cloneOldItem = oldItem.Clone() as EventCacheItem;
if (dataFilter == EventDataFilter.Metadata)
{
cloneOldItem.Value = null;
}
}
CacheEventArg eventArg = new CacheEventArg(key, cacheName, eventType, cloneItem, null, removedReason);
if (eventType == EventType.ItemUpdated)
{
eventArg.OldItem = cloneOldItem;
}
return(eventArg);
}
public virtual void OnCustomRemoveCallback(string key, object value, CacheItemRemovedReason reason,
BitSet flag, bool notifyAsync, EventCacheItem item)
{
try
{
object[] args = value as object[];
if (args != null)
{
object val = args[0];
CallbackInfo cbInfo = args[1] as CallbackInfo;
if (cbInfo != null)
{
if (_parent._perfStatsCollector != null)
{
_parent._perfStatsCollector.IncrementEventsProcessedPerSec();
}
if (item != null)
{
item.Value = GetObject(item.Value, flag);
}
EventHandle handle = new EventHandle((short)cbInfo.Callback);
_parent.EventManager.RaiseSelectiveCacheNotification(key, EventType.ItemRemoved, item, null,
reason, notifyAsync, handle, cbInfo.DataFilter);
}
}
}
catch
{
}
}
public virtual void OnCustomUpdateCallback(string key, object value, bool notifyAsync, EventCacheItem item,
EventCacheItem oldItem, BitSet flag)
{
try
{
CallbackInfo cbInfo = value as CallbackInfo;
if (cbInfo != null)
{
if (item != null)
{
item.Value = GetObject(item.Value, flag);
}
if (oldItem != null)
{
oldItem.Value = GetObject(oldItem.Value, flag);
}
if (_parent._perfStatsCollector != null)
{
_parent._perfStatsCollector.IncrementEventsProcessedPerSec();
}
EventHandle handle = new EventHandle((short)cbInfo.Callback);
this._eventManager.RaiseSelectiveCacheNotification(key, EventType.ItemUpdated, item, oldItem,
CacheItemRemovedReason.Underused, notifyAsync, handle, cbInfo.DataFilter);
}
}
catch
{
}
}
public void OnCustomUpdateCallback(short callbackId, string key, bool notifyAsync, EventCacheItem item,
EventCacheItem oldItem, BitSet flag, EventDataFilter dataFilter)
{
CallbackInfo cbInfo = new CallbackInfo(null, callbackId, dataFilter);
_listener.OnCustomUpdateCallback(key, cbInfo, notifyAsync, item, oldItem, flag);
}
internal EventArg(string cacheName, EventType eventType, EventCacheItem item, EventCacheItem oldItem)
{
_cacheName = cacheName;
_eventType = eventType;
_item = item;
_oldItem = oldItem;
}
internal EventArg(string cacheName, EventType eventType, EventCacheItem item, EventCacheItem oldItem)
{
_cacheName = cacheName;
_eventType = eventType;
_item = item;
_oldItem = oldItem;
}
public void OnItemUpdated(object key, EventContext eventContext)
{
EventCacheItem oldItem = null;
EventCacheItem item = null;
try
{
BitSet flag = new BitSet(0);
if (eventContext != null)
{
if (eventContext.OldItem != null)
{
oldItem = EventUtil.ConvertToItem(eventContext.OldItem);
}
if (eventContext.Item != null)
{
item = EventUtil.ConvertToItem(eventContext.Item);
}
if (_listener != null)
{
_listener.OnItemUpdated((string)key, true, item, oldItem, flag);
}
}
}
catch
{
}
}
public void OnCustomRemoveCallback(object key, object value, ItemRemoveReason reason, BitSet Flag,
EventContext eventContext)
{
EventCacheItem item = EventUtil.ConvertToItem(eventContext.Item);
CacheItemRemovedReason removeReason = EventUtil.ConvertToCIRemoveReason(reason);
_listener.OnCustomRemoveCallback((string)key, value, removeReason, Flag, true, item);
}
public object Clone()
{
EventCacheItem clone = new EventCacheItem();
clone._cacheItemPriority = _cacheItemPriority;
clone._value = _value;
return clone;
}
public object Clone()
{
EventCacheItem clone = new EventCacheItem();
clone._cacheItemPriority = _cacheItemPriority;
clone._value = _value;
return(clone);
}
internal void OnItemRemoved(string key, bool notifyAsync, EventCacheItem item)
{
try
{
this.FireCQEvents(key, EventType.ItemRemoved, item, null, notifyAsync, "", null,
EventDataFilter.DataWithMetadata); //Supressess all exceptions
}
catch (Exception)
{
}
}
public ItemUpdateCallbackTask(Broker parent, string key, short callBackId, bool notifyAsync, EventCacheItem item, EventCacheItem oldItem, BitSet flag,EventDataFilter dataFilter)
{
this._parent = parent;
this._key = key;
this._callBackId = callBackId;
this._notifyAsync = notifyAsync;
this._item = item;
this._oldItem = oldItem;
this._flag = flag;
this._dataFilter = dataFilter;
}
public ItemRemoveCallBackTask(Broker parent, string key, short callBackId, object value, CacheItemRemovedReason reason, BitSet flag, bool notifyAsync, EventCacheItem item,EventDataFilter dataFilter)
{
this._parent = parent;
this._key = key;
this._callBackId = callBackId;
this._value = value;
this._reason = reason;
this._flag = flag;
this._notifyAsync = notifyAsync;
this._item = item;
this._dataFilter = dataFilter;
}
internal void OnItemUpdated(string key, bool notifyAsync, EventCacheItem item, EventCacheItem oldItem)
{
try
{
this.FireCQEvents(key, EventType.ItemUpdated, item, oldItem, notifyAsync, "", null,
EventDataFilter.None); //Supressess all exceptions
}
catch (Exception)
{
//Logger
}
}
/// <summary>
/// TheadSafe and no locks internally
/// </summary>
/// <param name="key"></param>
/// <param name="eventType">Should contain one type i.e. should not be used as a flag.
/// Every EventType should be executed from another thread</param>
/// <param name="item"></param>
/// <param name="oldItem"></param>
/// <param name="reason"></param>
/// <param name="notifyAsync"></param>
internal void RaiseGeneralCacheNotification(string key, EventType eventType, EventCacheItem item,
EventCacheItem oldItem, CacheItemRemovedReason reason, bool notifyAsync)
{
try
{
object[] registeredDiscriptors = null;
ResourcePool eventPool = GetEventPool(eventType);
if (eventPool != null)
{
registeredDiscriptors = eventPool.GetAllResourceKeys();
}
if (registeredDiscriptors != null && registeredDiscriptors.Length > 0)
{
for (int i = 0; i < registeredDiscriptors.Length; i++)
{
CacheEventDescriptor discriptor = registeredDiscriptors[i] as CacheEventDescriptor;
if (discriptor == null)
{
continue;
}
var arg = CreateCacheEventArgument(discriptor.DataFilter, key, _cacheName, eventType, item, oldItem,
reason);
arg.Descriptor = discriptor;
if (notifyAsync)
{
#if !NETCORE
discriptor.CacheDataNotificationCallback.BeginInvoke(key, arg, asyn, null);
#elif NETCORE
TaskFactory factory = new TaskFactory();
Task task = factory.StartNew(() => discriptor.CacheDataNotificationCallback(key, arg));
#endif
}
else
{
discriptor.CacheDataNotificationCallback.Invoke(key, arg);
}
}
}
}
catch (Exception ex)
{
if (_logger != null && _logger.IsErrorEnabled)
{
_logger.CriticalInfo(ex.ToString());
}
}
}
/// <summary>
/// TheadSafe and no locks internally
/// </summary>
/// <param name="key"></param>
/// <param name="eventType">Should contain one type i.e. should not be used as a flag.
/// Every EventType should be executed from another thread</param>
/// <param name="item"></param>
/// <param name="oldItem"></param>
/// <param name="reason"></param>
/// <param name="_notifyAsync"></param>
/// <param name="eventhandle"></param>
internal void RaiseSelectiveCacheNotification(string key, EventType eventType, EventCacheItem item,
EventCacheItem oldItem, CacheItemRemovedReason reason, bool _notifyAsync, EventHandle eventhandle,
EventDataFilter dataFilter)
{
try
{
ResourcePool poolID = null;
CacheEventArg arg = null;
if ((eventType & EventType.ItemUpdated) != 0)
{
poolID = _selectiveUpdateEventIDPool;
}
else if ((eventType & EventType.ItemRemoved) != 0)
{
poolID = _selectiveRemoveEventIDPool;
}
arg = CreateCacheEventArgument(dataFilter, key, _cacheName, eventType, item, oldItem, reason);
if (poolID == null)
{
return;
}
CacheDataNotificationCallback callback =
poolID.GetResource((short)eventhandle.Handle) as CacheDataNotificationCallback;
if (callback == null)
{
return;
}
if (_notifyAsync)
{
System.Threading.ThreadPool.QueueUserWorkItem(waitC,
new object[] { callback, key, arg });
}
else
{
callback.Invoke(key, arg);
}
}
catch (Exception ex)
{
if (_logger != null && _logger.IsErrorEnabled)
{
_logger.CriticalInfo(ex.ToString());
}
}
}
public void OnItemAdded(string key, bool notifyAsync, EventCacheItem item, BitSet flag)
{
try
{
if (_listener != null)
{
_listener.OnItemAdded(key, notifyAsync, item, flag);
}
}
catch
{
}
}
public void OnItemRemoved(string key, object value, CacheItemRemovedReason reason, BitSet flag,
bool notifyAsync, EventCacheItem item)
{
try
{
if (_listener != null)
{
_listener.OnItemRemoved(key, value, reason, flag, notifyAsync, item);
}
}
catch (Exception e)
{
}
}
public object Clone()
{
EventCacheItem clone = new EventCacheItem();
clone._group = _group;
clone._subGroup = _subGroup;
clone._version = _version;
clone._resyncExpiredItems = _resyncExpiredItems;
clone._resyncProviderName = _resyncProviderName;
clone._cacheItemPriority = _cacheItemPriority;
clone._value = _value;
return(clone);
}
public void OnActiveQueryChanged(string queryId, QueryChangeType changeType, string key, bool notifyAsync,
EventCacheItem item, EventCacheItem oldItem, BitSet flag, EventDataFilter datafilter)
{
try
{
if (_listener != null)
{
_listener.OnActiveQueryChanged(queryId, changeType, key, notifyAsync, item, oldItem, flag,
datafilter);
}
}
catch
{
}
}
public virtual void OnItemRemoved(string key, object value, CacheItemRemovedReason reason, BitSet Flag,
bool notifyAsync, EventCacheItem item)
{
try
{
if (item != null && value != null)
{
item.Value = value = GetObject(value, Flag);
}
this._eventManager.RaiseGeneralCacheNotification(key, EventType.ItemRemoved, item, null, reason,
notifyAsync);
}
catch
{
}
}
public void OnItemAdded(object key, EventContext eventContext)
{
try
{
BitSet flag = new BitSet(0);
EventCacheItem item = EventUtil.ConvertToItem(eventContext.Item);
if (_listener != null)
{
_listener.OnItemAdded((string)key, true, item, flag);
}
}
catch
{
}
}
internal static EventCacheItem ConvertToEventEntry(Alachisoft.NCache.Common.Protobuf.EventCacheItem cacheItem)
{
Byte[] objectValue = null;
if (cacheItem == null) return null;
EventCacheItem item = new EventCacheItem();
item.CacheItemPriority = (CacheItemPriority)cacheItem.priority;
if (cacheItem.value != null && cacheItem.value.Count > 0)
{
UserBinaryObject ubObject = UserBinaryObject.CreateUserBinaryObject(cacheItem.value.ToArray());
objectValue = ubObject.GetFullObject();
item.Value = objectValue;
}
return item;
}
public virtual void OnItemAdded(object key, bool notifyAsync, EventCacheItem item, BitSet flag)
{
try
{
String keyString = key as string;
if (key != null)
{
if (item != null && item.Value != null)
{
item.Value = GetObject(item.Value, flag);
}
_eventManager.RaiseGeneralCacheNotification(keyString, EventType.ItemAdded, item, null,
CacheItemRemovedReason.Underused, notifyAsync);
}
}
catch
{
}
}
public virtual void OnActiveQueryChanged(string queryId, QueryChangeType changeType, string key,
bool notifyAsync, EventCacheItem item, EventCacheItem oldItem, BitSet flag, EventDataFilter datafilter)
{
if (item != null && item.Value != null)
{
item.Value = GetObject(item.Value, flag);
}
if (oldItem != null && oldItem.Value != null)
{
oldItem.Value = GetObject(oldItem.Value, flag);
}
ContinuousQueryManager.Notify(queryId, changeType, key, notifyAsync, item, oldItem, flag,
this._parent.CacheImpl.Name, datafilter);
if (_parent._perfStatsCollector != null)
{
_parent._perfStatsCollector.IncrementEventsProcessedPerSec();
}
}
public static void Notify(string queryId, QueryChangeType changeType, string key, bool notifyAsync,
EventCacheItem item, EventCacheItem oldItem, BitSet flag, string cacheName, EventDataFilter datafilter)
{
ContinuousQuery[] registeredQueries = null;
lock (sync)
{
if (queries.Count == 0)
{
return;
}
registeredQueries = new ContinuousQuery[queries.Count];
queries.CopyTo(registeredQueries);
}
foreach (ContinuousQuery query in registeredQueries)
{
try
{
if (query.ServerUniqueID.Equals(queryId))
{
if (changeType == QueryChangeType.Add)
{
query.FireCQEvents(key, Runtime.Events.EventType.ItemAdded, item, oldItem, notifyAsync,
cacheName, flag, datafilter);
}
else if (changeType == QueryChangeType.Remove)
{
query.FireCQEvents(key, Runtime.Events.EventType.ItemRemoved, item, oldItem, notifyAsync,
cacheName, flag, datafilter);
}
else
{
query.FireCQEvents(key, Runtime.Events.EventType.ItemUpdated, item, oldItem, notifyAsync,
cacheName, flag, datafilter);
}
}
}
catch (Exception e)
{
}
}
}
public virtual void OnItemUpdated(object key, bool notifyAsync, EventCacheItem item, EventCacheItem oldItem,
BitSet flag)
{
try
{
string ketString = key as string;
if (ketString != null)
{
if (item != null && item.Value != null)
{
item.Value = GetObject(item.Value, flag);
}
if (oldItem != null && oldItem.Value != null)
{
oldItem.Value = GetObject(oldItem.Value, flag);
}
this._eventManager.RaiseGeneralCacheNotification(ketString, EventType.ItemUpdated, item,
oldItem, CacheItemRemovedReason.Underused, notifyAsync);
}
}
catch (Exception e)
{
}
}
private CacheEventArg CreateCacheEventArgument(EventDataFilter dataFilter, string key,string cacheName,EventType eventType,EventCacheItem item,EventCacheItem oldItem,CacheItemRemovedReason removedReason)
{
EventCacheItem cloneItem = null;
EventCacheItem cloneOldItem = null;
if (dataFilter != EventDataFilter.None && item != null)
{
cloneItem = item.Clone() as EventCacheItem;
if (dataFilter == EventDataFilter.Metadata)
cloneItem.Value = null;
}
if (dataFilter != EventDataFilter.None && oldItem != null)
{
cloneOldItem = oldItem.Clone() as EventCacheItem;
if (dataFilter == EventDataFilter.Metadata)
cloneOldItem.Value = null;
}
CacheEventArg eventArg = new CacheEventArg(key, cacheName, eventType, cloneItem, null, removedReason);
if (eventType == EventType.ItemUpdated) eventArg.OldItem = cloneOldItem;
return eventArg;
}
/// <summary>
/// TheadSafe and no locks internally
/// </summary>
/// <param name="key"></param>
/// <param name="eventType">Should contain one type i.e. should not be used as a flag.
/// Every EventType should be executed from another thread</param>
/// <param name="item"></param>
/// <param name="oldItem"></param>
/// <param name="reason"></param>
/// <param name="_notifyAsync"></param>
/// <param name="eventhandle"></param>
internal void RaiseSelectiveCacheNotification(string key, EventType eventType, EventCacheItem item, EventCacheItem oldItem, CacheItemRemovedReason reason, bool _notifyAsync, EventHandle eventhandle,EventDataFilter dataFilter)
{
try
{
ResourcePool poolID = null;
CacheEventArg arg = null;
if ((eventType & EventType.ItemUpdated) != 0)
{
poolID = _selectiveUpdateEventIDPool;
}
else if ((eventType & EventType.ItemRemoved) != 0)
{
poolID = _selectiveRemoveEventIDPool;
}
arg = CreateCacheEventArgument(dataFilter, key, _cacheName, eventType, item, oldItem, reason);
if (poolID == null)
return;
CacheDataNotificationCallback callback = poolID.GetResource((short)eventhandle.Handle) as CacheDataNotificationCallback;
if (callback == null) //Can occur if Unregistered concurrently
return;
if (_notifyAsync)
System.Threading.ThreadPool.QueueUserWorkItem(waitC, new object[] { callback, key, arg}); //Faster and better
else
callback.Invoke(key, arg);
}
catch (Exception ex)
{
if (_logger != null && _logger.IsErrorEnabled) _logger.CriticalInfo(ex.ToString());
}
}
public virtual void OnCustomUpdateCallback(string key, object value, bool notifyAsync, EventCacheItem item,
EventCacheItem oldItem, BitSet flag)
{
try
{
CallbackInfo cbInfo = value as CallbackInfo;
if (cbInfo != null)
{
if (item != null) item.Value = GetObject(item.Value, flag);
if (oldItem != null) oldItem.Value = GetObject(oldItem.Value, flag);
if (_parent._perfStatsCollector != null)
_parent._perfStatsCollector.IncrementEventsProcessedPerSec();
EventHandle handle = new EventHandle((short) cbInfo.Callback);
this._eventManager.RaiseSelectiveCacheNotification(key, EventType.ItemUpdated, item, oldItem,
CacheItemRemovedReason.Underused, notifyAsync, handle, cbInfo.DataFilter);
}
}
catch
{
}
}
public virtual void OnCustomRemoveCallback(string key, object value, CacheItemRemovedReason reason, BitSet flag, bool notifyAsync, EventCacheItem item)
{
try
{
object[] args = value as object[];
if (args != null)
{
object val = args[0];
CallbackInfo cbInfo = args[1] as CallbackInfo;
if (cbInfo != null)
{
if (_parent._perfStatsCollector != null)
_parent._perfStatsCollector.IncrementEventsProcessedPerSec();
if (item != null) item.Value = GetObject(item.Value, flag);
EventHandle handle = new EventHandle((short)cbInfo.Callback);
_parent.EventManager.RaiseSelectiveCacheNotification(key, EventType.ItemRemoved, item, null, reason, notifyAsync, handle, cbInfo.DataFilter);
}
}
}
catch { }
}
internal CQEventArg(string cacheName, EventType eventType, EventCacheItem item, EventCacheItem oldItem)
: base(cacheName, eventType, item, oldItem)
{
}
public void OnCustomRemoveCallback(short callbackId, string key, object value,
CacheItemRemovedReason reason, BitSet Flag, bool notifyAsync, EventCacheItem item,
EventDataFilter dataFilter)
{
object[] val = new object[] { value, new CallbackInfo(null, callbackId, dataFilter) };
_listener.OnCustomRemoveCallback(key, val, reason, Flag, notifyAsync, item);
}
public void OnCustomUpdateCallback(short callbackId, string key, bool notifyAsync, EventCacheItem item, EventCacheItem oldItem, BitSet flag,EventDataFilter dataFilter)
{
CallbackInfo cbInfo = new CallbackInfo(null, callbackId,dataFilter);
_listener.OnCustomUpdateCallback(key, cbInfo, notifyAsync, item, oldItem, flag);
}
public void OnCustomRemoveCallback(short callbackId, string key, object value, CacheItemRemovedReason reason, BitSet Flag, bool notifyAsync, EventCacheItem item,EventDataFilter dataFilter)
{
object[] val = new object[] { value, new CallbackInfo(null, callbackId,dataFilter) };
_listener.OnCustomRemoveCallback(key, val, reason, Flag, notifyAsync, item);
}
internal CacheEventArg(string key, string cachename, EventType eventType, EventCacheItem item, CacheEventDescriptor discriptor, EventCacheItem olditem)
: base(cachename, eventType, item, olditem)
{
_descriptor = discriptor;
}
internal CacheEventArg(string key, string cachename, EventType eventType, EventCacheItem item, CacheEventDescriptor discriptor, CacheItemRemovedReason reason)
: base(cachename, eventType, item)
{
_reason = reason;
_descriptor = discriptor;
}
/// <summary>
/// For Inproc only
/// </summary>
/// <param name="entry"></param>
/// <returns></returns>
internal static EventCacheItem ConvertToItem(EventCacheEntry entry)
{
Byte[] objectValue = null;
if (entry != null)
{
EventCacheItem item = new EventCacheItem();
item.CacheItemPriority = (CacheItemPriority)entry.Priority;
if (entry.Value != null)
{
UserBinaryObject ubObject = entry.Value as UserBinaryObject;
if (ubObject != null)
{
objectValue = ubObject.GetFullObject();
item.Value = objectValue;
}
else
item.Value = entry.Value;
}
return item;
}
return null;
}
internal CacheEventArg(string key, string cachename, EventType eventType, EventCacheItem item, CacheEventDescriptor discriptor, EventCacheItem olditem)
: base(cachename, eventType, item, olditem)
{
_descriptor = discriptor;
}
internal void FireCQEvents(string key, EventType eventType, EventCacheItem item, EventCacheItem oldItem,
bool notifyAsync, string cacheName, BitSet flag, EventDataFilter datafilter)
{
try
{
CQEventArg arg = null;
ICollection collection = null;
ResourcePool pool = null;
ResourcePool filterPool = null;
if ((eventType & EventType.ItemAdded) != 0 && _cqAddEventPool != null)
{
pool = _cqAddEventPool;
collection = _cqAddEventPool.Keys;
filterPool = _cqAddEventDataFilter;
}
else if ((eventType & EventType.ItemUpdated) != 0 && _cqUpdateEventPool != null)
{
pool = _cqUpdateEventPool;
collection = _cqUpdateEventPool.Keys;
filterPool = _cqUpdateEventDataFilter;
}
else if ((eventType & EventType.ItemRemoved) != 0 && _cqRemoveEventPool != null)
{
pool = _cqRemoveEventPool;
collection = _cqRemoveEventPool.Keys;
filterPool = _cqRemoveEventDataFilter;
}
else
{
return;
}
if (collection != null && collection.Count > 0)
{
QueryDataNotificationCallback[] disc = null;
lock (syncLock)
{
disc = new QueryDataNotificationCallback[collection.Count];
collection.CopyTo(disc, 0); //to avoid locking
}
for (int i = 0; i < disc.Length; i++)
{
short index = -1;
object obj = pool.GetResource(disc[i]);
index = Convert.ToInt16(obj);
if (index > -1)
{
//Not to fire event if datafilter recieved is less than requried OR noDF present
EventDataFilter queryDataFilter = (EventDataFilter)filterPool.GetResource(index);
if ((eventType & EventType.ItemAdded) != 0)
{
arg = CreateCQEventArgument(queryDataFilter, key, cacheName, EventType.ItemAdded, item,
oldItem);
}
else if ((eventType & EventType.ItemUpdated) != 0)
{
arg = CreateCQEventArgument(queryDataFilter, key, cacheName, EventType.ItemUpdated,
item, oldItem);
}
else if ((eventType & EventType.ItemRemoved) != 0)
{
arg = CreateCQEventArgument(queryDataFilter, key, cacheName, EventType.ItemRemoved,
item, oldItem);
}
else
{
return;
}
arg.ContinuousQuery = this;
if (notifyAsync)
{
#if !NETCORE
disc[i].BeginInvoke(key, arg, asyn, disc[i]);
#elif NETCORE
TaskFactory factory = new TaskFactory();
int temp = i;
Task task = factory.StartNew(() => disc[temp](key, arg));
#endif
}
else
{
disc[i].Invoke(key, arg);
}
}
}
}
}
catch (Exception ex)
{
}
}
