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;
}
