private void RunAssertionPerformanceSynthetic(EPServiceProvider epService) { var numLoop = 100000; var stmt = epService.EPAdministrator.CreateEPL( "select TheString, IntPrimitive from SupportBean(IntPrimitive > 10)"); var results = new List<object[]>(); var listener = new UpdateEventHandler( (sender, args) => { var newEvents = args.NewEvents; var theString = (string) newEvents[0].Get("TheString"); var val = newEvents[0].Get("IntPrimitive").AsInt(); results.Add(new object[] {theString, val}); }); stmt.Events += listener; var start = PerformanceObserver.MilliTime; for (var i = 0; i < numLoop; i++) { epService.EPRuntime.SendEvent(new SupportBean("E1", 1000 + i)); } var end = PerformanceObserver.MilliTime; Assert.AreEqual(numLoop, results.Count); for (var i = 0; i < numLoop; i++) { EPAssertionUtil.AssertEqualsAnyOrder(results[i], new object[] {"E1", 1000 + i}); } Assert.IsTrue(end - start < 1000, "delta=" + (end - start)); stmt.Dispose(); }
public FunapiHttpDownloader(string target_path, bool enable_verify, UpdateEventHandler on_update, FinishEventHandler on_finished) : this(target_path, enable_verify) { UpdateCallback = new UpdateEventHandler(on_update); FinishedCallback = new FinishEventHandler(on_finished); }
private EPStatement CreateEPL(String epl, UpdateEventHandler eventHandler) { EPStatement statement = _epAdministrator.CreateEPL(epl); statement.Events += eventHandler; return(statement); }
public virtual void AddEventScript(string EventType, LuaFunction Event) { if (EventType.ToLower() == "update") { OnUpdate += new UpdateEventHandler(delegate(object s, UpdateEventArgs e) { Event.Call(s, e); }); } }
// Initialises variables and sets delegates. public override void Initialise() { base.Initialise(); onUpdateEvent += progression.SpawnObstaclesOnInterval; onPlayerLost += sounds.StopBackgroundMusic; }
public async Task UpdateEventHandlerInvokesUpdateEventWithCorrectEvent() { var message = new UpdateEvent { Event = new Event() }; var dataAccess = new Mock<IAllReadyDataAccess>(); var sut = new UpdateEventHandler(dataAccess.Object); await sut.Handle(message); dataAccess.Verify(x => x.UpdateEvent(message.Event), Times.Once); }
public static ILoad CreateTcpLoad(UpdateEventHandler errorHandler = null) { if (tcpLoad == null) { tcpLoad = new TcpLoad(); tcpLoad.SetEventHandler(errorHandler); } return(tcpLoad); }
/// <summary> /// Removes all event handlers. /// </summary> public void RemoveAllEventHandlers() { _eventHandler = null; if (_eventHandler == null) { _eventSubscriber.Dispose(); _eventSubscriber = null; } }
/// <summary> /// 创建httpLoad /// </summary> /// <returns></returns> public static ILoad CreateHttpLoad(UpdateEventHandler errorHandler = null) { if (httpLoad == null) { httpLoad = new HttpLoad(); httpLoad.SetEventHandler(errorHandler); } return(httpLoad); }
public static T Events <T>(this T obj, UpdateEventHandler updateEvent = null) where T : IDynamicNotificable, IDrawable { if (updateEvent != null) { obj.UpdateEvent += updateEvent; } return(obj); }
protected virtual void FireUpdateEvent(object sender, EventArgs e) { UpdateEventHandler handler = EventUpdate; if (handler != null) { handler(sender, e); } }
private static int GetEventHandleLength() { int length = 0; length += (DeleteEventHandler == null) ? 0 : DeleteEventHandler.GetInvocationList().Length; length += (UpdateEventHandler == null) ? 0 : UpdateEventHandler.GetInvocationList().Length; length += (AddEventHandler == null) ? 0 : AddEventHandler.GetInvocationList().Length; return(length); }
/// <summary> /// Allows an owner to update the meta-data about one of its things in the Thing Registry. /// /// Note: Meta information updated in this way will only overwrite tags provided in the request, and leave other tags previously /// reported as is. /// </summary> /// <param name="NodeId">Node ID of thing, if behind a concentrator.</param> /// <param name="SourceId">Source ID of thing, if behind a concentrator.</param> /// <param name="Partition">Partition of thing, if behind a concentrator.</param> /// <param name="ThingJid">JID of thing. Required if an owner wants to update the meta-data about one of its things. Leave empty, /// if the thing wants to update its own meta-data.</param> /// <param name="MetaDataTags">Meta-data tags to register with the registry.</param> /// <param name="Callback">Callback method.</param> /// <param name="State">State object passed on to callback method.</param> public void UpdateThing(string NodeId, string SourceId, string Partition, string ThingJid, MetaDataTag[] MetaDataTags, UpdateEventHandler Callback, object State) { StringBuilder Request = new StringBuilder(); Request.Append("<update xmlns='"); Request.Append(NamespaceDiscovery); if (!string.IsNullOrEmpty(ThingJid)) { Request.Append("' jid='"); Request.Append(XML.Encode(ThingJid)); } this.AddNodeInfo(Request, NodeId, SourceId, Partition); Request.Append("'>"); string RegistryAddress = this.AddTags(Request, MetaDataTags, this.thingRegistryAddress); Request.Append("</update>"); this.client.SendIqSet(RegistryAddress, Request.ToString(), (sender, e) => { if (Callback != null) { XmlElement E = e.FirstElement; bool Disowned = false; if (e.Ok && E != null && E.LocalName == "disowned" && E.NamespaceURI == NamespaceDiscovery) { Disowned = true; if (string.IsNullOrEmpty(NodeId) && string.IsNullOrEmpty(SourceId) && string.IsNullOrEmpty(Partition) && this.client.TryGetExtension(typeof(ProvisioningClient), out IXmppExtension Extension) && Extension is ProvisioningClient ProvisioningClient) { ProvisioningClient.OwnerJid = string.Empty; } } UpdateEventArgs e2 = new UpdateEventArgs(e, State, Disowned); try { Callback(this, e2); } catch (Exception ex) { Log.Critical(ex); } } }, null); }
public async Task UpdateEventHandlerInvokesUpdateEventWithCorrectEvent() { var message = new UpdateEvent { Event = new Event() }; var dataAccess = new Mock <IAllReadyDataAccess>(); var sut = new UpdateEventHandler(dataAccess.Object); await sut.Handle(message); dataAccess.Verify(x => x.UpdateEvent(message.Event), Times.Once); }
private HttpLoadHelper GetHttpLoadHelper(DownFileVO downFileVO, UpdateEventHandler completeLoadHandler, bool isLocal = true, bool needSave = false) { HttpLoadHelper htttpLoadHelper = new HttpLoadHelper(); htttpLoadHelper.completeLoadHandler = completeLoadHandler; htttpLoadHelper.FileVO = downFileVO; htttpLoadHelper.NeedSave = needSave; htttpLoadHelper.TimeOut = timeOut; htttpLoadHelper.IsLocal = isLocal; return(htttpLoadHelper); }
public FraudMonitor(EPServiceProvider epService, UpdateEventHandler eventHandler) { string joinStatement = "select fraud.accountNumber as accountNumber, fraud.warning as warning, withdraw.amount as amount, " + "max(fraud.timestamp, withdraw.timestamp) as timestamp, 'withdrawlFraudWarn' as descr from " + "FraudWarning.win:time(30 min) as fraud," + "Withdrawal.win:time(30 sec) as withdraw" + " where fraud.accountNumber = withdraw.accountNumber"; joinView = epService.EPAdministrator.CreateEPL(joinStatement); joinView.Events += eventHandler; }
private void update_OnCheckUpdateStop(UpdateManager sender, string message) { if (picUpdateCheck.InvokeRequired) { var d = new UpdateEventHandler(update_OnCheckUpdateStop); Invoke(d, new object[] { sender, message }); } else { picUpdateCheck.Image = Resources.feed_green; UpdateEventMessage(message); } }
void Button2Click(object sender, EventArgs e) { //listBox1.BeginUpdate(); foreach (string s in listBox1.SelectedItems) { Globals.full_files_name_variables.Remove(s); } listBox1.DataSource = null; listBox1.DataSource = Globals.full_files_name_variables; update(Globals.full_files_name_variables.Count); textBox1.Text = ""; UpdateEventHandler.Invoke(this, args); }
private void update_OnDownloadStart(UpdateManager sender, string message) { if (picDownload.InvokeRequired) { var d = new UpdateEventHandler(update_OnDownloadStart); Invoke(d, new object[] { sender, message }); } else { downloadRefreshTimer.Enabled = true; picDownload.Image = Resources.download_orange; UpdateEventMessage(message); } }
public Poisen(SkillArg arg, ActorExt target, uint additionID, int damage = 0, int duration = 5000) : base(target, "Poisen", duration, 2000) { this.arg = arg; this.target = target; this.additionID = additionID; this.damage = damage; if (target.Tasks.TryGetValue("Poisen", out Task task)) { task.Deactivate(); } target.Tasks["Poisen"] = this; OnAdditionStart += new StartEventHandler(ActorFrosen_OnAdditionStart); OnAdditionEnd += new EndEventHandler(ActorFrosen_OnAdditionEnd); OnUpdate += new UpdateEventHandler(Poisen_OnUpdate); }
void Button1Click(object sender, EventArgs e) { OpenFileDialog FD = new System.Windows.Forms.OpenFileDialog(); FD.Multiselect = true; // textBox1.Text = ""; if (FD.ShowDialog() == System.Windows.Forms.DialogResult.OK) { foreach (string s in FD.FileNames) { // TaskDialog.Show("Revit",s); if (!Globals.full_files_name_variables.Contains(s)) { Globals.full_files_name_variables.Add(s); } } } listBox1.DataSource = null; listBox1.DataSource = Globals.full_files_name_variables; update(Globals.full_files_name_variables.Count); //UpdateEventArgs args = new UpdateEventArgs(); UpdateEventHandler.Invoke(this, args); }
/// <summary> /// 触发事件 /// </summary> /// <param name="dt"></param> /// <param name="HourPer"></param> public void Notify(object prame) { ThreadParameter pThreadparameter = prame as ThreadParameter; //检查委托是否为空 UpdateEventHandler pEventHandler = Update; if (pEventHandler != null) { foreach (UpdateEventHandler handler in pEventHandler.GetInvocationList()) { try { //异步调用委托 handler.BeginInvoke(pThreadparameter.Datetime, pThreadparameter.HourPer, null, null); //循环调用每一个事件,防止其中一个报错,使得下面的事件不被执行 //handler(pThreadparameter.Datetime, pThreadparameter.HourPer); } catch (Exception ex) { SystemLog.GetInstance().Info(ex.Message); } } } }
public void TestRun() { _idCounter = 0L; _executorService = Executors.NewCachedThreadPool(); _noActionUpdateEventHandler = (sender, arg) => { }; var epConfig = new Configuration(); epConfig.AddEventType <SupportBean>(); epConfig.EngineDefaults.ThreadingConfig.InsertIntoDispatchLocking = ConfigurationEngineDefaults.Threading.Locking.SUSPEND; EPServiceProvider epServiceProvider = EPServiceProviderManager.GetDefaultProvider(epConfig); epServiceProvider.Initialize(); _epAdministrator = epServiceProvider.EPAdministrator; _epRuntime = epServiceProvider.EPRuntime; _epAdministrator.StartAllStatements(); String epl = "insert into Stream1 select count(*) as cnt from SupportBean.win:time(7 sec)"; CreateEPL(epl, delegate { }); epl = epl + " output every 10 seconds"; CreateEPL(epl, delegate { }); var sendTickEventRunnable = new SendEventRunnable <object>(SendEvent, 10000); Start(sendTickEventRunnable, 4); // Adjust here for long-running test Thread.Sleep(3000); _executorService.Shutdown(); _executorService.AwaitTermination(new TimeSpan(0, 0, 1)); }
public static T SetUpdate <T>(this T d, UpdateEventHandler callback) where T : IDynamicNotificable { d.UpdateEvent += callback; return(d); }
private void update_OnUpdateError(UpdateManager sender, string message) { if (picUpdateCheck.InvokeRequired) { var d = new UpdateEventHandler(update_OnUpdateError); Invoke(d, new object[] { sender, message }); } else { UpdateEventMessage(message); UpdateInProgress = false; if (SilentUpdate) { ShutDown(); } } }
private static void ChangedEvent(IntPtr userData, NotificationType type, IntPtr operationList, int num) { IntPtr operationType; IntPtr uniqueNumber; IntPtr notification; NotificationEventArgs eventargs; NotificationDeleteEventArgs deleteargs; for (int i = 0; i < num; i++) { uniqueNumber = IntPtr.Zero; operationType = IntPtr.Zero; notification = IntPtr.Zero; Interop.NotificationEventListener.GetOperationData(operationList + (i * Marshal.SizeOf <NotificationOperation>()), NotificationOperationDataType.Type, out operationType); Interop.NotificationEventListener.GetOperationData(operationList + (i * Marshal.SizeOf <NotificationOperation>()), NotificationOperationDataType.UniqueNumber, out uniqueNumber); Interop.NotificationEventListener.GetOperationData(operationList + (i * Marshal.SizeOf <NotificationOperation>()), NotificationOperationDataType.Notification, out notification); if (operationType == IntPtr.Zero) { Log.Error(LogTag, "unable to get operationType"); continue; } Log.Info(LogTag, "type : " + ((int)operationType).ToString()); Log.Info(LogTag, "Add : " + (AddEventHandler == null ? "0" : AddEventHandler.GetInvocationList().Length.ToString())); Log.Info(LogTag, "update: " + (UpdateEventHandler == null ? "0" : UpdateEventHandler.GetInvocationList().Length.ToString())); Log.Info(LogTag, "delete : " + (DeleteEventHandler == null ? "0" : DeleteEventHandler.GetInvocationList().Length.ToString())); switch ((int)operationType) { case (int)NotificationOperationType.Insert: if (notification != IntPtr.Zero) { try { eventargs = NotificationEventArgsBinder.BindObject(notification, false); AddEventHandler?.Invoke(null, eventargs); } catch (Exception e) { Log.Error(LogTag, e.Message); } } break; case (int)NotificationOperationType.Update: if (notification != IntPtr.Zero) { try { eventargs = NotificationEventArgsBinder.BindObject(notification, false); UpdateEventHandler?.Invoke(null, eventargs); } catch (Exception e) { Log.Error(LogTag, e.Message); } } break; case (int)NotificationOperationType.Delete: if (uniqueNumber != IntPtr.Zero) { try { deleteargs = NotificationDeleteEventArgsBinder.BindObject((int)uniqueNumber); DeleteEventHandler?.Invoke(null, deleteargs); } catch (Exception e) { Log.Error(LogTag, e.Message); } } break; default: Log.Info(LogTag, "Event : " + (int)operationType); break; } } }
public void AddUpdateEventHandler(object sender, UpdateEventHandler handler) { lock(_UpdateEventList) _UpdateEventList.Add(new KeyValuePair<object, UpdateEventHandler>(sender, handler)); }
protected void update_main_form() //update gridview in main form { UpdateEventArgs args = new UpdateEventArgs(); //create new update event args object UpdateEventHandler.Invoke(this, args); }
/// <summary> /// sammelt alle benötigten Konstruktoren /// </summary> /// <param name="pin_DelegateAufAlleUpdateEventHandler"></param> /// <param name="pin_ObjektIDMenge"></param> /// <param name="pin_AktuellerUpdateEventHandler"></param> public UpdateEventsThreadContainer( ref UpdateEventHandler pin_DelegateAufAlleUpdateEventHandler, int[] pin_ObjektIDMenge, UpdateEventHandler pin_AktuellerUpdateEventHandler) { _DelegateAufAlle = pin_DelegateAufAlleUpdateEventHandler; _UpdateEventArgs = new UpdateEventArgs(pin_ObjektIDMenge); _AktuellerUpdateEventHandler = pin_AktuellerUpdateEventHandler; }
public void UpdateAndDelete() { UpdateHandler args = new UpdateHandler(); UpdateEventHandler.Invoke(this, args); }
private void update_OnUpdateProcessStart(UpdateManager sender, string message) { if (btnCheckUpdate.InvokeRequired) { var d = new UpdateEventHandler(update_OnUpdateProcessStart); Invoke(d, new object[] { sender, message }); } else { UpdateInProgress = true; UpdateEventMessage(message); } }
public CheckForUpdates(String versionUrl, UpdateEventHandler updateRequiredHandler) : this(versionUrl) { this.updateRequired = updateRequiredHandler; }
public void RegisterGlobalHandler(UpdateEventHandler handler) { foreach (var s in _statements) s.Events += handler; }
private void update_OnUpdateProcessStop(UpdateManager sender, string message) { if (btnCheckUpdate.InvokeRequired) { var d = new UpdateEventHandler(update_OnUpdateProcessStop); Invoke(d, new object[] { sender, message }); } else { UpdateInProgress = false; UpdateEventMessage(message); switch (Settings.XbmcAutostart) { //Always case 1: { _logger.Info("XBMC is set to always autostart"); XbmcManager.StartXbmc(); ShutDown(); break; } //Only if closed case 2: { _logger.Info("XBMC is set to auto start only if it was closed."); if (XbmcManager.XbmcTerminated) { _logger.Info("XBMC was terminated during this session"); XbmcManager.StartXbmc(); ShutDown(); } break; } } if (SilentUpdate) { ShutDown(); } } }
static PhraseEngine() { upd += new UpdateEventHandler(UpdateArrayAsync); levelCount = PhraseRepository.CountElementsInLevels(); }
/// <summary> /// privater Konstruktor /// </summary> /// <param name="target">delegate auf die Zielmethode</param> private UpdateEventAdapter(UpdateEventHandler pin_Ziel) { this._Ziel += pin_Ziel; }
/// <summary> /// Initializes a new instance of the <see cref="DelegateUpdateListener"/> class. /// </summary> /// <param name="procUpdate">The proc update.</param> public DelegateUpdateListener(UpdateEventHandler procUpdate) { ProcUpdate = procUpdate; }
private void update_OnUnZipStart(UpdateManager sender, string message) { if (picUnzip.InvokeRequired) { var d = new UpdateEventHandler(update_OnUnZipStart); Invoke(d, new object[] { sender, message }); } else { picUnzip.Image = Resources.unzip_orange; UpdateEventMessage(message); } }
public void SetUpdateEvent(UpdateEventHandler addEvent) { updateEvent += new UpdateEventHandler(addEvent); }
protected void insert() { UpdateEventArgs args = new UpdateEventArgs(); UpdateEventHandler.Invoke(this, args); }
public void AddEventHandlerWithReplay(UpdateEventHandler eventHandler) { }
/// <summary> /// entfernt ungültige Delegates aus der Liste der registrierten Delegates /// </summary> /// <param name="pin_UpdateEventHandler"></param> private void EntferneUngueltigenDelegate(UpdateEventHandler pin_UpdateEventHandler) { // warten bis Mutex frei ist _Mutex.WaitOne(); try { // suche den aktuellen Delegate in der Liste aller Delegates foreach(Delegate tmpDel in _DelegateAufAlle.GetInvocationList()) { if (tmpDel == pin_UpdateEventHandler) // entferne ihn _DelegateAufAlle -= pin_UpdateEventHandler; } } catch { } // gib Mutex wieder frei _Mutex.ReleaseMutex(); }
/// <summary> /// Add an event handler to the current statement and replays current statement /// results to the handler. /// <para/> /// The handler receives current statement results as the first call to the Update /// method of the event handler, passing in the newEvents parameter the current statement /// results as an array of zero or more events. Subsequent calls to the Update /// method of the event handler are statement results. /// <para/> /// Current statement results are the events returned by the GetEnumerator or /// GetSafeEnumerator methods. /// <para/> /// Delivery of current statement results in the first call is performed by the /// same thread invoking this method, while subsequent calls to the event handler may /// deliver statement results by the same or other threads. /// <para/> /// Note: this is a blocking call, delivery is atomic: Events occurring during /// iteration and delivery to the event handler are guaranteed to be delivered in a separate /// call and not lost. The event handler implementation should minimize long-running or /// blocking operations. /// <para/> /// Delivery is only atomic relative to the current statement. If the same event handler /// instance is registered with other statements it may receive other statement /// result s simultaneously. /// <para/> /// If a statement is not started an therefore does not have current results, the /// event handler receives a single invocation with a null listenerSet in newEvents. /// </summary> /// <param name="eventHandler">eventHandler that will receive events</param> public void AddEventHandlerWithReplay(UpdateEventHandler eventHandler) { if (eventHandler == null) { throw new ArgumentNullException("eventHandler", "Null listener reference supplied"); } if (IsDisposed) { throw new IllegalStateException("Statement is in destroyed state"); } using (StatementContext.DefaultAgentInstanceLock.AcquireReadLock()) { _statementListenerSet.Events.Add(eventHandler); StatementContext.StatementResultService.SetUpdateListeners(_statementListenerSet, false); if (_statementLifecycleSvc != null) { _statementLifecycleSvc.DispatchStatementLifecycleEvent( new StatementLifecycleEvent(this, StatementLifecycleEvent.LifecycleEventType.LISTENER_ADD, eventHandler)); } IEnumerator <EventBean> enumerator = GetEnumerator(); var events = new List <EventBean>(); while (enumerator.MoveNext()) { events.Add(enumerator.Current); } try { if (events.IsEmpty()) { eventHandler.Invoke( this, new UpdateEventArgs( ServiceProvider, this, null, null)); } else { eventHandler.Invoke( this, new UpdateEventArgs( ServiceProvider, this, events.ToArray(), null)); } } catch (Exception exception) { Log.Error( "Unexpected exception invoking eventHandler for replay on event handler '{0}' : {1} : {2}", eventHandler.GetType().Name, exception.GetType().Name, exception.Message); } finally { if (StatementContext.EpStatementHandle.HasTableAccess) { StatementContext.TableExprEvaluatorContext.ReleaseAcquiredLocks(); } } } }
protected void raiseUpdate() { UpdateEventArgs args = new UpdateEventArgs(); UpdateEventHandler?.Invoke(this, args); }
/// <summary> /// erzeugt ein neues Objekt dieser Klasse /// </summary> /// <param name="target">delegate auf die Zielmethode</param> /// <returns>delegate auf this.UpdateEvent</returns> public static UpdateEventHandler Create(UpdateEventHandler pin_Ziel) { UpdateEventAdapter shim = new UpdateEventAdapter(pin_Ziel); UpdateEventHandler pout = new UpdateEventHandler(shim.UpdateEvent); return pout; }