static ChildWindowEvents()
{
EventsUtil.initFields(typeof(ChildWindowEvents), delegate(FieldInfo field, Object eventDelegate)
{
field.SetValue(null, eventDelegate);
});
}
static GenericViewModelEvents()
{
EventsUtil.initFields(typeof(GenericViewModelEvents), delegate(FieldInfo field, Object eventDelegate)
{
field.SetValue(null, eventDelegate);
});
}
internal CacheEventDescriptor RegisterGeneralEvents(CacheDataNotificationCallback callback, EventType eventType, EventDataFilter datafilter)
{
if (callback != null)
{
//Avoiding new ResourcePool(inside = new Hashtable) at constructor level
if (_addEventPool == null)
{
_addEventPool = new ResourcePool();
}
if (_removeEventPool == null)
{
_removeEventPool = new ResourcePool();
}
if (_updateEventPool == null)
{
_updateEventPool = new ResourcePool();
}
CacheEventDescriptor discriptor = CacheEventDescriptor.CreateCacheDiscriptor(eventType, _cacheName, callback, datafilter);
//Registers the handl)
bool registeredDescriptor = RegisterGeneralDiscriptor(discriptor, EventsUtil.GetEventTypeInternal(eventType));
if (!registeredDescriptor)
{
return(null);
}
return(discriptor);
}
else
{
return(null);
}
}
static FrameworkElementEvents()
{
EventsUtil.initFields(typeof(FrameworkElementEvents), delegate(FieldInfo field, Object eventDelegate)
{
field.SetValue(null, eventDelegate);
});
}
static INotifyPropertyChangedEvents()
{
EventsUtil.initFields(typeof(INotifyPropertyChangedEvents), delegate(FieldInfo field, Object eventDelegate)
{
field.SetValue(null, eventDelegate);
});
}
static TextBoxEvents()
{
EventsUtil.initFields(typeof(TextBoxEvents), delegate(FieldInfo field, Object eventDelegate)
{
field.SetValue(null, eventDelegate);
});
}
static ContentControlEvents()
{
EventsUtil.initFields(typeof(ContentControlEvents), delegate(FieldInfo field, Object eventDelegate)
{
field.SetValue(null, eventDelegate);
});
}
public void UnRegisterCacheNotification(string key, CacheDataNotificationCallback callback, EventType EventType)
{
if (key == null)
{
throw new ArgumentNullException("key");
}
if (callback == null)
{
throw new ArgumentNullException("callback");
}
CacheContainer.UnRegisterCacheNotification(key, callback, EventsUtil.GetEventTypeInternal(EventType));
}
public void UnRegisterCacheNotification(IEnumerable <string> keys, CacheDataNotificationCallback callback, EventType EventType)
{
if (keys == null)
{
throw new ArgumentNullException("key");
}
string[] keysList = new List <string>(keys).ToArray();
for (int i = 0; i < keysList.Length; i++)
{
if (string.IsNullOrEmpty(keysList[i]))
{
throw new ArgumentNullException("key can't be null or empty");
}
}
if (callback == null)
{
throw new ArgumentException("callback");
}
CacheContainer.UnRegisterCacheNotification(keysList, callback, EventsUtil.GetEventTypeInternal(EventType));
}
internal EventHandle UnregisterDiscriptor(CacheEventDescriptor discriptor)
{
if (discriptor == null || !discriptor.IsRegistered)
{
return(null);
}
foreach (EventType type in Enum.GetValues(typeof(EventType)))
{
ResourcePool pool = null;
#region Pool selection
if ((type & discriptor.RegisteredAgainst) != 0)
{
pool = GetEventPool(EventsUtil.GetEventTypeInternal(type));
}
if (pool == null)
{
continue;
}
#endregion
short registrationSequenceId = -1;
bool unregisterNotification = false;
EventDataFilter maxDataFilter = EventDataFilter.None;
lock (SyncLockGeneral)
{
object retVal = pool.RemoveResource(discriptor);
if (retVal == null)
{
continue;
}
unregisterNotification = pool.Count == 0;
if (!unregisterNotification)
{
object[] pooledDescriptors = pool.GetAllResourceKeys();
if (pooledDescriptors != null)
{
for (int i = 0; i < pooledDescriptors.Length; i++)
{
CacheEventDescriptor pooledDescriptor = pooledDescriptors[i] as CacheEventDescriptor;
if (pooledDescriptor.DataFilter > maxDataFilter)
{
maxDataFilter = pooledDescriptor.DataFilter;
}
}
}
}
discriptor.IsRegistered = false;
//keeps a sequence number
switch (type)
{
case EventType.ItemAdded:
//Data filter is being updated
if (maxDataFilter != _generalAddDataFilter)
{
_generalAddDataFilter = maxDataFilter;
registrationSequenceId = ++_addEventRegistrationSequence;
}
if (unregisterNotification)
{
_generalAddDataFilter = EventDataFilter.None;
}
break;
case EventType.ItemRemoved:
if (maxDataFilter != _generalRemoveDataFilter)
{
_generalRemoveDataFilter = maxDataFilter;
registrationSequenceId = ++_removeEventRegistrationSequenceId;
}
if (unregisterNotification)
{
_generalAddDataFilter = EventDataFilter.None;
}
break;
case EventType.ItemUpdated:
if (maxDataFilter != _generalUpdateDataFilter)
{
_generalUpdateDataFilter = maxDataFilter;
registrationSequenceId = ++_updateEventRegisrationSequenceId;
}
if (unregisterNotification)
{
_generalAddDataFilter = EventDataFilter.None;
}
break;
}
}
if (_cache != null)
{
if (unregisterNotification)
{
//client is no more interested in event, therefore unregister it from server
_cache.UnregiserGeneralCacheNotification(EventsUtil.GetEventTypeInternal(type));
}
else if (registrationSequenceId != -1)
{
//only caused update of data filter either upgrade or downgrade
_cache.RegisterCacheNotificationDataFilter(EventsUtil.GetEventTypeInternal(type), maxDataFilter, registrationSequenceId);
}
}
}
return(null);
}
/// <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(EventsUtil.GetEventTypeInternal(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 bitSet = new BitSet();
if (_cache.SerializationFormat == Common.Enum.SerializationFormat.Json)
{
bitSet.SetBit(BitSetConstants.JsonData);
}
if (item != null)
{
item.SetValue(_cache.SafeDeserialize <object>(item.GetValue <object>(), _cache.SerializationContext, bitSet, UserObjectType.CacheItem));
}
if (oldItem != null)
{
oldItem.SetValue(_cache.SafeDeserialize <object>(oldItem.GetValue <object>(), _cache.SerializationContext, bitSet, UserObjectType.CacheItem));
}
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
//TODO: ALACHISOFT (BeginInvoke is not supported in .Net Core thus using TaskFactory)
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());
}
}
}
