//unsubscribe this event from event matching eventType public void Unsubscribe(IObserver listener, EventTypes eventType) { if (listenerTable.Keys.Contains(eventType)) { listenerTable[eventType].Remove(listener); } }
public void SaveAuditEvent(AuditLoggingEvent info) { try { EventTypes type = (EventTypes)Enum.Parse(typeof(EventTypes), info.Level.ToString()); using (var unit = ServiceLocator.Current.GetInstance <IUnitOfWork>()) { Event evt = new Event() { TypeID = (int)type, ProcessName = info.FriendlyProcessName, Message = info.Message.ToString(), ExceptionMessage = info.ExceptionObject == null ? string.Empty : info.ExceptionObject.Message, StackTrace = info.ExceptionObject == null ? string.Empty : info.ExceptionObject.StackTrace }; unit.Scope.Repository <Event>().Add(evt); unit.Save(); } } catch (Exception) { Console.WriteLine("Could not log exception to db. Exception was @0", info.Message.ToString()); } }
public IOWatcher(IntPtr fd, EventTypes types, Loop loop, Action<IOWatcher, EventTypes> callback) : base(loop) { this.fd = fd; this.callback = callback; watcher_ptr = manos_io_watcher_create (fd.ToInt32 (), types, watcherCallback, GCHandle.ToIntPtr (gc_handle)); }
public void Add() { CreateDate = DateTime.Now; UpdateDate = null; Status = RecordStatuses.ACTIVE; EventType = EventTypes.ADDED; }
public MainEvent() { InitializeComponent(); List<string> hours = new List<string>(); for (int i = 0; i < 24; i++) { hours.Add(i.ToString("00")); } cbFromHour.ItemsSource = hours; cbFromHour.SelectedIndex = 0; cbUntilHour.ItemsSource = hours; cbUntilHour.SelectedIndex = 0; List<string> minutes = new List<string>(); for (int i = 0; i < 12; i++) { minutes.Add((i * 5).ToString("00")); } cbFromMin.ItemsSource = minutes; cbFromMin.SelectedIndex = 0; cbUntilMin.ItemsSource = minutes; cbUntilMin.SelectedIndex = 0; dpFromDate.SelectedDate = DateTime.Now.Date; dpUntilDate.SelectedDate = DateTime.Now.AddHours(1).Date; mEventTypes = new EventTypes(); cbEventTypes.ItemsSource = mEventTypes; }
public void Notify(EventTypes eventTypeFilter, string message) { foreach (var listner in _listners.Where(x => x.Subscriptions.Contains(eventTypeFilter))) { listner.Alert(message); } }
public void Send(SessionState sessionState, ISendProtocol sendProtocol, EventTypes eventType, Int32 refNum) { var header = new Header { eventType = eventType.ToString(), refNum = refNum, }; try { header.message = sendProtocol?.SerializeJSON(new Message { sessionState = sessionState, header = header, }); } catch (Exception ex) { ex.Log(); } var json = JsonConvert.SerializeObject(new object[] { header.eventType.ToString(), header.refNum, header.message, }); WebAsyncSocket.Send(sessionState, connectionState, json); }
private void ProcessWork(Loop loop, IAsyncWatcher watcher, EventTypes revents) { int remaining = maxWorkPerLoop + 1; while (--remaining > 0) { Action action; if (workQueue.TryDequeue(out action)) { try { action(); } catch (Exception ex) { Console.WriteLine("Error in processing synchronized action"); Console.WriteLine(ex); } } else { break; } } if (remaining == 0) { asyncWatcher.Send(); } }
internal virtual void HandleEnd(Loop loop, IAsyncWatcher watcher, EventTypes revents) { if (OnEnd != null) { OnEnd(); } }
public static void RaiseEventMessage(object sender, string Message, EventTypes type) { if (EventMessage != null) { EventMessage(sender, Message, type); } }
/// <summary> /// add user selected event types /// </summary> /// <param name="evt"></param> public void AddEventType(EventTypes evt) { if (_eventSelectors.All(e => e != evt)) { _eventSelectors.Add(evt); } }
/* Subscribers/listeners register with the event system */ public void Subscribe(IObserver listener, EventTypes eventType) { if (!listenerTable.Keys.Contains(eventType)) { listenerTable[eventType] = new HashSet<IObserver>(); } listenerTable[eventType].Add(listener); }
public UniEvent(EventTypes type) { Type = type; Actions = new List<UniAction>(); Options = new JSONObject(); Options.AddField("type", Type.ToString()); }
public string GetEventTypeName(EventTypes eventType) { #if !NET20 return GetInteropDelegate<GetEventTypeName>().Invoke(eventType).ToStringAnsi(); #else return IntPtrExtensions.ToStringAnsi(GetInteropDelegate<GetEventTypeName>().Invoke(eventType)); #endif }
void HandleReadReady(Loop loop, IOWatcher watcher, EventTypes revents) { if (readTimeoutContinuation == null) { readTimeoutContinuation = DateTime.Now; } HandleRead(); }
/// <summary> /// Creates new instance. /// </summary> /// <param name="message">Message.</param> /// <param name="endpoint">Endpoint.</param> /// <param name="type">Event type.</param> /// <param name="exception">Exception.</param> public MessageLogEventArgs(string message, string endpoint, EventTypes type, Exception exception) : this(message) { Endpoint = endpoint; EventType = type; Exception = exception; Time = InternalDate.Now; }
static OfflineAwardHandler() { EventTypes.RegistRequestType("area.offlineAwardHandler.queryAllAreasRequest", typeof(QueryAllAreasRequest), typeof(QueryAllAreasResponse)); EventTypes.RegistRequestType("area.offlineAwardHandler.setOfflineAreaIdRequest", typeof(SetOfflineAreaIdRequest), typeof(SetOfflineAreaIdResponse)); EventTypes.RegistRequestType("area.offlineAwardHandler.queryOfflineAwardRequest", typeof(QueryOfflineAwardRequest), typeof(QueryOfflineAwardResponse)); EventTypes.RegistRequestType("area.offlineAwardHandler.getOfflineAwardRequest", typeof(GetOfflineAwardRequest), typeof(GetOfflineAwardResponse)); EventTypes.RegistRequestType("area.offlineAwardHandler.getCurrentOfflineAreaRequest", typeof(GetCurrentOfflineAreaRequest), typeof(GetCurrentOfflineAreaResponse)); }
static GuildBlessHandler() { EventTypes.RegistPushType("area.guildBlessPush.blessRefreshPush", typeof(BlessRefreshPush)); EventTypes.RegistRequestType("area.guildBlessHandler.getMyBlessInfoRequest", typeof(GetMyBlessInfoRequest), typeof(GetMyBlessInfoResponse)); EventTypes.RegistRequestType("area.guildBlessHandler.blessActionRequest", typeof(BlessActionRequest), typeof(BlessActionResponse)); EventTypes.RegistRequestType("area.guildBlessHandler.receiveBlessGiftRequest", typeof(ReceiveBlessGiftRequest), typeof(ReceiveBlessGiftResponse)); EventTypes.RegistRequestType("area.guildBlessHandler.upgradeBlessRequest", typeof(UpgradeBlessRequest), typeof(UpgradeBlessResponse)); }
static ShopMallHandler() { EventTypes.RegistRequestType("area.shopMallHandler.getMallTabsRequest", typeof(GetMallTabsRequest), typeof(GetMallTabsResponse)); EventTypes.RegistRequestType("area.shopMallHandler.getMallScoreItemListRequest", typeof(GetMallScoreItemListRequest), typeof(GetMallScoreItemListResponse)); EventTypes.RegistRequestType("area.shopMallHandler.buyMallItemRequest", typeof(BuyMallItemRequest), typeof(BuyMallItemResponse)); EventTypes.RegistRequestType("area.shopMallHandler.getMallItemListRequest", typeof(GetMallItemListRequest), typeof(GetMallItemListResponse)); EventTypes.RegistRequestType("area.shopMallHandler.buyMallScoreItemRequest", typeof(BuyMallScoreItemRequest), typeof(BuyMallScoreItemResponse)); }
void HandleWriteReady(Loop loop, IOWatcher watcher, EventTypes revents) { if (writeTimeoutContinuation == null) { writeTimeoutContinuation = DateTime.Now; } HandleWrite(); }
public Outing(EventTypes eventType, int numPeople, DateTime date, decimal totalCost) { EventType = eventType; NumPeople = numPeople; Date_ = date; TotalCost = totalCost; TotalCostPerPerson = Math.Round(totalCost / numPeople, 2); }
public IEventValidator Create(EventTypes eventType) { //Получаем тип валидатора по его имени var validatorType = Type.GetType($"{_ns}.{eventType}Validation", true); //создаем экземпляр валидатора return((IEventValidator)Activator.CreateInstance(validatorType)); }
public static void Subscribe(EventTypes evT, EventHandler <MessageEventArgs> handler) { if (!handlers.ContainsKey(evT)) { handlers.Add(evT, new List <EventHandler <MessageEventArgs> >()); } handlers[evT].Add(handler); }
public EventAggregate(EventTypes eventType, string eventName, int eventCount) { EventType = eventType; EventName = eventName; EventCount = eventCount; }
public EventBuilder Type(EventTypes Value) { if (!this.IsLocked) { this.vType = Value; } return(this); }
/// <summary> /// 添加事件监听 /// </summary> public static void AddListener(EventTypes eventType, Action <object> callback) { if (!m_EventDict.ContainsKey(eventType)) { m_EventDict.Add(eventType, null); } m_EventDict[eventType] += callback; }
static AchievementHandler() { EventTypes.RegistPushType("area.achievementPush.onAchievementPush", typeof(OnAchievementPush)); EventTypes.RegistRequestType("area.achievementHandler.achievementGetTypeElementRequest", typeof(AchievementGetTypeElementRequest), typeof(AchievementGetTypeElementResponse)); EventTypes.RegistRequestType("area.achievementHandler.achievementGetAwardRequest", typeof(AchievementGetAwardRequest), typeof(AchievementGetAwardResponse)); EventTypes.RegistRequestType("area.achievementHandler.getHolyArmorsRequest", typeof(GetHolyArmorsRequest), typeof(GetHolyArmorsResponse)); EventTypes.RegistRequestType("area.achievementHandler.activateHolyArmorRequest", typeof(ActivateHolyArmorRequest), typeof(ActivateHolyArmorResponse)); }
public int AttachEvent(VlcEventManagerInstance eventManagerInstance, EventTypes eventType, EventCallback callback) { if (eventManagerInstance == IntPtr.Zero) throw new ArgumentException("Event manager instance is not initialized."); if (callback == null) throw new ArgumentException("Callback for event is not initialized."); return GetInteropDelegate<AttachEvent>().Invoke(eventManagerInstance, eventType, callback, IntPtr.Zero); }
static RewardHandler() { EventTypes.RegistRequestType("area.rewardHandler.rewardDeskRequest", typeof(RewardDeskRequest), typeof(RewardDeskResponse)); EventTypes.RegistRequestType("area.rewardHandler.rewardRequest", typeof(RewardRequest), typeof(RewardResponse)); EventTypes.RegistRequestType("area.rewardHandler.checkBountyRequest", typeof(CheckBountyRequest), typeof(CheckBountyResponse)); EventTypes.RegistRequestType("area.rewardHandler.getHasFinishRequest", typeof(FinishRewardRequest), typeof(FinishRewardResponse)); EventTypes.RegistRequestType("area.rewardHandler.getAwardBountyRequest", typeof(GetAwardBountyRequest), typeof(GetAwardBountyResponse)); }
/// <summary> /// 触发事件 /// </summary> /// <param name="eventType">事件类型</param> /// <param name="args">参数列表</param> public void TriggerEvent(EventTypes eventType, params object[] args) { eventCollection.TryGetValue(eventType, out Delegate eventValue); if (eventValue != null) { eventValue.DynamicInvoke(args); } }
private void HandlePrepareEvent(Loop loop, PrepareWatcher watcher, EventTypes revents) { if (!running) { loop.Unloop(UnloopType.All); prepare_watcher.Stop(); } }
static SaleHandler() { EventTypes.RegistRequestType("area.saleHandler.buyPageRequest", typeof(BuyPageRequest), typeof(BuyPageResponse)); EventTypes.RegistRequestType("area.saleHandler.buyItemRequest", typeof(BuyItemRequest), typeof(BuyItemResponse)); EventTypes.RegistRequestType("area.saleHandler.autoBuyItemByCodeRequest", typeof(AutoBuyItemByCodeRequest), typeof(AutoBuyItemByCodeResponse)); EventTypes.RegistRequestType("area.saleHandler.sellItemsRequest", typeof(SellItemsRequest), typeof(SellItemsResponse)); EventTypes.RegistRequestType("area.saleHandler.rebuyItemRequest", typeof(RebuyItemRequest), typeof(RebuyItemResponse)); }
public ActionResult DeleteConfirmed(int id) { EventTypes eventTypes = db.EventTypes.Find(id); db.EventTypes.Remove(eventTypes); db.SaveChanges(); return(RedirectToAction("Index")); }
static FunctionOpenHandler() { EventTypes.RegistPushType("area.functionOpenPush.functionOpenListPush", typeof(FunctionOpenListPush)); EventTypes.RegistPushType("area.functionOpenPush.functionAwardListPush", typeof(FunctionAwardListPush)); EventTypes.RegistRequestType("area.functionOpenHandler.getFunctionListRequest", typeof(GetFunctionListRequest), typeof(GetFunctionListResponse)); EventTypes.RegistRequestType("area.functionOpenHandler.setFunctionPlayedRequest", typeof(SetFunctionPlayedRequest), typeof(SetFunctionPlayedResponse)); EventTypes.RegistRequestType("area.functionOpenHandler.receiveFunctionAwardRequest", typeof(ReceiveFunctionAwardRequest), typeof(ReceiveFunctionAwardResponse)); }
private void OnDonePoll(Loop loop, AsyncWatcher watcher, EventTypes revents) { if (eio_poll() != -1) { Console.WriteLine("OnDonePoll: starting idle watcher"); idle_watcher.Stop(); } }
void PrimSetEventHandlerAttr(EventTypes type, string script) { if (_handlerAttrs == null) { _handlerAttrs = new Dictionary <EventTypes, string>(); } _handlerAttrs[type] = script; }
public TimelineEvent(string target, EventTypes eventType, bool isVisible, string description, string path) { Target = target; IsVisible = isVisible; EventType = eventType; DisplayedText = description; Arguments = path; }
public string GetEventTypeName(EventTypes eventType) { #if !NET20 return(GetInteropDelegate <GetEventTypeName>().Invoke(eventType).ToStringAnsi()); #else return(IntPtrExtensions.ToStringAnsi(GetInteropDelegate <GetEventTypeName>().Invoke(eventType))); #endif }
public IOWatcher(IntPtr fd, EventTypes types, LibEvLoop loop, IOWatcherCallback callback) : base(loop) { this.fd = fd; this.callback = callback; watcher_ptr = manos_io_watcher_create(fd.ToInt32(), types | EventTypes.EV__IOFDSET, watcherCallback, GCHandle.ToIntPtr(gc_handle)); }
private static void StaticCallback(IntPtr loop, IntPtr watcher, EventTypes revents) { UnmanagedPrepareWatcher iow = (UnmanagedPrepareWatcher) Marshal.PtrToStructure (watcher, typeof (UnmanagedPrepareWatcher)); GCHandle gchandle = GCHandle.FromIntPtr (iow.data); PrepareWatcher w = (PrepareWatcher) gchandle.Target; w.callback (w.Loop, w, revents); }
private static void StaticCallback(IntPtr data, EventTypes revents) { try { var handle = GCHandle.FromIntPtr (data); var watcher = (IOWatcher) handle.Target; watcher.callback (watcher, revents); } catch (Exception e) { Console.Error.WriteLine ("Error handling IO readyness event: {0}", e.Message); Console.Error.WriteLine (e.StackTrace); } }
// all event handler attribute accessors should eventually call these public static string GetEventHandlerAttr(mdr.DObject obj, EventTypes type, string name) { #if ENABLE_RR if (RecordReplayManager.Instance != null && RecordReplayManager.Instance.RecordEnabled) { mwr.RecordReplayManager.Instance.Record("Element", null, "GetEventHandlerAttr", false, obj, type, name); } #endif var targetElement = obj.FirstInPrototypeChainAs<HTMLElement>(); var s = targetElement.PrimGetEventHandlerAttr(type); Debug.WriteLine("GetEventHandlerAttr({0}) = '{1}'", name, s); return s; }
public bool EventIsActive(Bands b, int c, EventTypes e) { if (e == EventTypes.BEAT) { return bandData[bandOffsets[c, (int) b]].Beat; } else if (e == EventTypes.VIBRATION) { return bandData[bandOffsets[c, (int) b]].Vibration; } return false; }
static void StaticCallback(IntPtr data, EventTypes revents) { Error.Log.Call<System.Exception>(() => { var handle = GCHandle.FromIntPtr(data); var watcher = (IOWatcher)handle.Target; watcher.callback(watcher, revents); }, e => { Console.Error.WriteLine("Error handling IO readyness event: {0}", e.Message); Console.Error.WriteLine(e.StackTrace); }); }
/// <summary> /// Gets event list models by event type /// </summary> /// <param name="eventType">Event type to get by</param> /// <returns>An event list model</returns> private EventListModel FetchFromRedis(EventTypes eventType) { try { var redisClient = new RedisClient("localhost"); var eventClient = redisClient.As<EventListModel>(); return eventClient.GetById((int)eventType); } catch (Exception) { return new EventListModel(); } }
public IOWatcher(IntPtr fd, EventTypes types, Loop loop, IOWatcherCallback callback) : base(loop) { this.fd = fd; this.callback = callback; unmanaged_watcher = new UnmanagedIOWatcher (); unmanaged_watcher.fd = fd.ToInt32 (); unmanaged_watcher.events = types | EventTypes.EV__IOFDSET; unmanaged_watcher.callback = CallbackFunctionPtr; InitializeUnmanagedWatcher (unmanaged_watcher); }
public void LogEvent(string message, EventTypes eType) { log4net.Config.XmlConfigurator.Configure(GetTestConfig()); if (eType==EventTypes.Info) { Log.Info(message); }else if (eType==EventTypes.Warn) { Log.Warn(message); }else if (eType==EventTypes.Error) { Log.Error(message); } else if (eType == EventTypes.Fatal) { Log.Fatal(message); } else { Log.Info(message); } }
public EventHandlerProperty(EventTypes eventType) : base() { EventType = eventType; TargetValueType = mdr.ValueTypes.Function; //We should static or constants in the following methods to avoid expensive delegates! OnGetDValue = (mdr.DObject This, ref mdr.DValue v) => { var eventListeners = GetEventListeners(This, eventType); var idlListener = eventListeners.IdlListener; if (idlListener != null) v.Set(idlListener); else v.Set(mdr.Runtime.Instance.DefaultDNull); }; OnSetDValue = (mdr.DObject This, ref mdr.DValue v) => { var eventListeners = GetEventListeners(This, eventType); Debug.WriteLine("Setting the IDL listener for event type " + eventType.ToString() + " : type " + v.ValueType.ToString()); var idlListener = (v.ValueType == mdr.ValueTypes.Function) ? v.AsDFunction() : null; eventListeners.IdlListener = idlListener; }; }
public UserControl(EventTypes eventType, int streamId = 1, int bufferlength = 1000, int pingTime = 0) : base(4) { var memory = new MemoryStream(); var writer = new EndianBinaryWriter(EndianBitConverter.Big, memory); writer.Write((ushort) eventType); switch (eventType) { case EventTypes.StreamBegin: writer.Write(streamId); break; case EventTypes.StreamEOF: writer.Write(streamId); break; case EventTypes.StreamDry: writer.Write(streamId); break; case EventTypes.SetBufferLength: writer.Write(streamId); writer.Write(bufferlength); break; case EventTypes.StreamIsRecorded: writer.Write(streamId); break; case EventTypes.PingRequest: writer.Write(pingTime); break; case EventTypes.PingResponse: writer.Write(pingTime); break; default: break; } Data = memory.ToArray(); }
protected override void UnmanagedCallbackHandler(IntPtr _loop, IntPtr _watcher, EventTypes revents) { // Maybe I should verify the pointers? callback (Loop, this, revents); }
public EventPacket(EventTypes type, byte[] data) { Type = type; Data = data; }
private static extern IntPtr manos_io_watcher_create(int fd, EventTypes revents, UnmanagedWatcherCallback callback, IntPtr data);
private void HandleIOEvents(Loop loop, IOWatcher watcher, EventTypes revents) { while (true) { Socket s = null; try { s = Socket.Accept (); } catch (SocketException se) { if (se.SocketErrorCode == SocketError.WouldBlock || se.SocketErrorCode == SocketError.TryAgain) return; Console.WriteLine ("Socket exception in Accept handler"); Console.WriteLine (se); return; } catch (Exception e) { Console.WriteLine ("Exception in Accept handler"); Console.WriteLine (e); return; } IOStream iostream = new IOStream (s, IOLoop); transactions.Add (HttpTransaction.BeginTransaction (this, iostream, s, callback)); } }
public EventKeyDown(EventTypes type) : base(type) { Priority = 10; }
public MyEventArgs(EventTypes type) { Type = type; }
public BIEventTestDatabaseRow(int eventId, EventTypes eventType, DateTime eventDate) { AddGetInt32ColumnValue("EventId", eventId); AddGetInt32ColumnValue("EventType", (int)eventType); AddGetDateTimeColumnValue("EventDate", eventDate); }
private void HandleIOEvents(Loop loop, IOWatcher watcher, EventTypes revents) { while (true) { Socket s = null; try { s = Socket.Accept (); } catch (SocketException se) { if (se.SocketErrorCode == SocketError.WouldBlock || se.SocketErrorCode == SocketError.TryAgain) return; throw se; } catch { throw; } IOStream iostream = new IOStream (s, IOLoop); transactions.Add (HttpTransaction.BeginTransaction (this, iostream, s, callback)); } }
public static string GetEventReference(EventTypes en) { return referenceBase.GetReference(en); }
/// <summary> /// Get event type name. /// </summary> /// <param name="type"></param> /// <returns></returns> public static String GetEventTypeName(EventTypes type) { return InteropHelper.PtrToString(_getTypeNameFunction.Delegate(type)); }
/// <summary> /// Deattach a event with a callback. /// </summary> /// <param name="type">event type</param> /// <param name="callback">callback which will be called when event case</param> /// <param name="userData">some custom data</param> public void Detach(EventTypes type, LibVlcEventCallBack callback, IntPtr userData) { _eventDetachFunction.Delegate(InstancePointer, type, callback, userData); }