Neuron®
The Neuron® is the basis for the creation of open and secure federated networks for smart societies.
Loading...
Searching...
No Matches
EventHandlerExtensions.cs
1using System;
2using System.Text;
3using System.Threading.Tasks;
4
5namespace Waher.Events
6{
7 #region Delegates
8
12 public delegate Task EventHandlerAsync(object Sender, EventArgs e);
13
17 public delegate Task EventHandlerAsync<in T>(object Sender, T e);
18
24 public delegate void Callback<in T>(T Arg);
25
31 public delegate Task CallbackAsync<in T>(T Arg);
32
33 #endregion
34
38 public static class EventHandlerExtensions
39 {
40 #region Synchronous event handlers, non-communication-layers
41
48 public static bool Raise(this EventHandler EventHandler, object Sender)
49 {
50 return Raise(EventHandler, Sender, EventArgs.Empty, false);
51 }
52
61 public static bool Raise(this EventHandler EventHandler, object Sender, bool Decoupled)
62 {
63 return Raise(EventHandler, Sender, EventArgs.Empty, Decoupled);
64 }
65
73 public static bool Raise(this EventHandler EventHandler, object Sender, EventArgs e)
74 {
75 return EventHandler.Raise(Sender, e, false);
76 }
77
87 public static bool Raise(this EventHandler EventHandler, object Sender, EventArgs e, bool Decoupled)
88 {
89 if (!(EventHandler is null))
90 {
91 if (Decoupled)
92 {
93 Task.Run(() =>
94 {
95 try
96 {
97 EventHandler(Sender, e);
98 }
99 catch (Exception ex)
100 {
101 Log.Exception(ex);
102 }
103 });
104 }
105 else
106 {
107 try
108 {
109 EventHandler(Sender, e);
110 }
111 catch (Exception ex)
112 {
113 Log.Exception(ex);
114 return false;
115 }
116 }
117 }
118
119 return true;
120 }
121
129 public static bool Raise<T>(this EventHandler<T> EventHandler, object Sender, T e)
130 {
131 return EventHandler.Raise(Sender, e, false);
132 }
133
143 public static bool Raise<T>(this EventHandler<T> EventHandler, object Sender, T e, bool Decoupled)
144 {
145 if (!(EventHandler is null))
146 {
147 if (Decoupled)
148 {
149 Task.Run(() =>
150 {
151 try
152 {
153 EventHandler(Sender, e);
154 }
155 catch (Exception ex)
156 {
157 Log.Exception(ex);
158 }
159 });
160 }
161 else
162 {
163 try
164 {
165 EventHandler(Sender, e);
166 }
167 catch (Exception ex)
168 {
169 Log.Exception(ex);
170 return false;
171 }
172 }
173 }
174
175 return true;
176 }
177
178 #endregion
179
180 #region Synchronous event handlers, communication layers
181
188 public static bool Raise(this EventHandler EventHandler, IObservableLayer Sender)
189 {
190 return Raise(EventHandler, Sender, EventArgs.Empty, Sender?.DecoupledEvents ?? false);
191 }
192
201 public static bool Raise(this EventHandler EventHandler, IObservableLayer Sender, bool Decoupled)
202 {
203 return Raise(EventHandler, Sender, EventArgs.Empty, Decoupled);
204 }
205
213 public static bool Raise(this EventHandler EventHandler, IObservableLayer Sender, EventArgs e)
214 {
215 return EventHandler.Raise(Sender, e, Sender?.DecoupledEvents ?? false);
216 }
217
227 public static bool Raise(this EventHandler EventHandler, IObservableLayer Sender, EventArgs e, bool Decoupled)
228 {
229 if (EventHandler is null)
230 Sender.NoEventHandlerWarning(e);
231 else if (Decoupled)
232 {
233 Task _ = Task.Run(() =>
234 {
235 try
236 {
237 EventHandler(Sender, e);
238 }
239 catch (Exception ex)
240 {
241 Log.Exception(ex);
242
243 if (!(Sender is null))
244 {
245 try
246 {
247 Sender.Exception(ex);
248 }
249 catch (Exception ex2)
250 {
251 Log.Exception(ex2);
252 }
253 }
254 }
255 });
256
257 return true;
258 }
259 else
260 {
261 try
262 {
263 EventHandler(Sender, e);
264 }
265 catch (Exception ex)
266 {
267 Log.Exception(ex);
268 Sender?.Exception(ex);
269 return false;
270 }
271 }
272
273 return true;
274 }
275
281 private static void NoEventHandlerWarning(this IObservableLayer Sender, object e)
282 {
283 if (Sender is null)
284 return;
285
286 StringBuilder sb = new StringBuilder();
287
288 sb.Append("No event handler registered (");
289 sb.Append(Sender.GetType().FullName);
290 sb.Append(", ");
291 sb.Append(e.GetType().FullName);
292 sb.Append(")");
293
294 Sender.Warning(sb.ToString());
295 }
296
304 public static bool Raise<T>(this EventHandler<T> EventHandler, IObservableLayer Sender, T e)
305 {
306 return EventHandler.Raise(Sender, e, Sender?.DecoupledEvents ?? false);
307 }
308
318 public static bool Raise<T>(this EventHandler<T> EventHandler, IObservableLayer Sender, T e, bool Decoupled)
319 {
320 if (EventHandler is null)
321 Sender.NoEventHandlerWarning(e);
322 else if (Decoupled)
323 {
324 Task _ = Task.Run(() =>
325 {
326 try
327 {
328 EventHandler(Sender, e);
329 }
330 catch (Exception ex)
331 {
332 Log.Exception(ex);
333
334 if (!(Sender is null))
335 {
336 try
337 {
338 Sender.Exception(ex);
339 }
340 catch (Exception ex2)
341 {
342 Log.Exception(ex2);
343 }
344 }
345 }
346 });
347
348 return true;
349 }
350 else
351 {
352 try
353 {
354 EventHandler(Sender, e);
355 }
356 catch (Exception ex)
357 {
358 Log.Exception(ex);
359 Sender?.Exception(ex);
360 return false;
361 }
362 }
363
364 return true;
365 }
366
367 #endregion
368
369 #region Asynchronous event handlers, non-communication-layers
370
377 public static Task<bool> Raise(this EventHandlerAsync EventHandler, object Sender)
378 {
379 return Raise(EventHandler, Sender, EventArgs.Empty, false);
380 }
381
390 public static Task<bool> Raise(this EventHandlerAsync EventHandler, object Sender, bool Decoupled)
391 {
392 return Raise(EventHandler, Sender, EventArgs.Empty, Decoupled);
393 }
394
402 public static Task<bool> Raise(this EventHandlerAsync EventHandler, object Sender, EventArgs e)
403 {
404 return EventHandler.Raise(Sender, e, false);
405 }
406
416 public static async Task<bool> Raise(this EventHandlerAsync EventHandler, object Sender, EventArgs e, bool Decoupled)
417 {
418 if (!(EventHandler is null))
419 {
420 if (Decoupled)
421 {
422 Task _ = Task.Run(async () =>
423 {
424 try
425 {
426 await EventHandler(Sender, e);
427 }
428 catch (Exception ex)
429 {
430 Log.Exception(ex);
431 }
432 });
433 }
434 else
435 {
436 try
437 {
438 await EventHandler(Sender, e);
439 }
440 catch (Exception ex)
441 {
442 Log.Exception(ex);
443 return false;
444 }
445 }
446 }
447
448 return true;
449 }
450
458 public static Task<bool> Raise<T>(this EventHandlerAsync<T> EventHandler, object Sender, T e)
459 {
460 return EventHandler.Raise(Sender, e, false);
461 }
462
472 public static async Task<bool> Raise<T>(this EventHandlerAsync<T> EventHandler, object Sender, T e, bool Decoupled)
473 {
474 if (!(EventHandler is null))
475 {
476 if (Decoupled)
477 {
478 Task _ = Task.Run(async () =>
479 {
480 try
481 {
482 await EventHandler(Sender, e);
483 }
484 catch (Exception ex)
485 {
486 Log.Exception(ex);
487 }
488 });
489 }
490 else
491 {
492 try
493 {
494 await EventHandler(Sender, e);
495 }
496 catch (Exception ex)
497 {
498 Log.Exception(ex);
499 return false;
500 }
501 }
502 }
503
504 return true;
505 }
506
507 #endregion
508
509 #region Asynchronous event handlers, communication layers
510
517 public static Task<bool> Raise(this EventHandlerAsync EventHandler, IObservableLayer Sender)
518 {
519 return Raise(EventHandler, Sender, EventArgs.Empty, Sender?.DecoupledEvents ?? false);
520 }
521
530 public static Task<bool> Raise(this EventHandlerAsync EventHandler, IObservableLayer Sender, bool Decoupled)
531 {
532 return Raise(EventHandler, Sender, EventArgs.Empty, Decoupled);
533 }
534
542 public static Task<bool> Raise(this EventHandlerAsync EventHandler, IObservableLayer Sender, EventArgs e)
543 {
544 return EventHandler.Raise(Sender, e, Sender?.DecoupledEvents ?? false);
545 }
546
556 public static async Task<bool> Raise(this EventHandlerAsync EventHandler, IObservableLayer Sender, EventArgs e, bool Decoupled)
557 {
558 if (EventHandler is null)
559 Sender.NoEventHandlerWarning(e);
560 else if (Decoupled)
561 {
562 Task _ = Task.Run(async () =>
563 {
564 try
565 {
566 await EventHandler(Sender, e);
567 }
568 catch (Exception ex)
569 {
570 Log.Exception(ex);
571
572 if (!(Sender is null))
573 {
574 try
575 {
576 Sender.Exception(ex);
577 }
578 catch (Exception ex2)
579 {
580 Log.Exception(ex2);
581 }
582 }
583 }
584 });
585
586 return true;
587 }
588 else
589 {
590 try
591 {
592 await EventHandler(Sender, e);
593 }
594 catch (Exception ex)
595 {
596 Log.Exception(ex);
597 Sender?.Exception(ex);
598 return false;
599 }
600 }
601
602 return true;
603 }
604
612 public static Task<bool> Raise<T>(this EventHandlerAsync<T> EventHandler, IObservableLayer Sender, T e)
613 {
614 return EventHandler.Raise(Sender, e, Sender?.DecoupledEvents ?? false);
615 }
616
626 public static async Task<bool> Raise<T>(this EventHandlerAsync<T> EventHandler, IObservableLayer Sender, T e, bool Decoupled)
627 {
628 if (EventHandler is null)
629 Sender.NoEventHandlerWarning(e);
630 else if (Decoupled)
631 {
632 Task _ = Task.Run(async () =>
633 {
634 try
635 {
636 await EventHandler(Sender, e);
637 }
638 catch (Exception ex)
639 {
640 Log.Exception(ex);
641
642 if (!(Sender is null))
643 {
644 try
645 {
646 Sender.Exception(ex);
647 }
648 catch (Exception ex2)
649 {
650 Log.Exception(ex2);
651 }
652 }
653 }
654 });
655
656 return true;
657 }
658 else
659 {
660 try
661 {
662 await EventHandler(Sender, e);
663 }
664 catch (Exception ex)
665 {
666 Log.Exception(ex);
667 Sender?.Exception(ex);
668 return false;
669 }
670 }
671
672 return true;
673 }
674
675 #endregion
676
677 #region Synchronous callback functions
678
684 public static void Call<ArgT>(this Callback<ArgT> Callback, ArgT Argument)
685 {
686 if (!(Callback is null))
687 {
688 try
689 {
690 Callback(Argument);
691 }
692 catch (Exception ex)
693 {
694 Log.Exception(ex);
695 }
696 }
697 }
698
699 #endregion
700
701 #region Asynchronous callback functions
702
708 public static async Task Call<ArgT>(this CallbackAsync<ArgT> Callback, ArgT Argument)
709 {
710 if (!(Callback is null))
711 {
712 try
713 {
714 await Callback(Argument);
715 }
716 catch (Exception ex)
717 {
718 Log.Exception(ex);
719 }
720 }
721 }
722
723 #endregion
724 }
725}
Waher.Events.EventHandlerExtensions
Static class with method extensions simplifying raising events.
Definition: EventHandlerExtensions.cs:39
Waher.Events.EventHandlerExtensions.Raise
static Task< bool > Raise(this EventHandlerAsync EventHandler, object Sender, EventArgs e)
Raises an event, if handler is defined. Any exceptions are trapped and logged.
Definition: EventHandlerExtensions.cs:402
Waher.Events.EventHandlerExtensions.Raise
static Task< bool > Raise(this EventHandlerAsync EventHandler, object Sender)
Raises an event, if handler is defined. Any exceptions are trapped and logged.
Definition: EventHandlerExtensions.cs:377
Waher.Events.EventHandlerExtensions.Raise
static bool Raise(this EventHandler EventHandler, object Sender, EventArgs e)
Raises an event, if handler is defined. Any exceptions are trapped and logged.
Definition: EventHandlerExtensions.cs:73
Waher.Events.EventHandlerExtensions.Raise< T >
static bool Raise< T >(this EventHandler< T > EventHandler, object Sender, T e)
Raises an event, if handler is defined. Any exceptions are trapped and logged.
Definition: EventHandlerExtensions.cs:129
Waher.Events.EventHandlerExtensions.Raise
static Task< bool > Raise(this EventHandlerAsync EventHandler, IObservableLayer Sender)
Raises an event, if handler is defined. Any exceptions are trapped and logged.
Definition: EventHandlerExtensions.cs:517
Waher.Events.EventHandlerExtensions.Raise
static bool Raise(this EventHandler EventHandler, IObservableLayer Sender)
Raises an event, if handler is defined. Any exceptions are trapped and logged.
Definition: EventHandlerExtensions.cs:188
Waher.Events.EventHandlerExtensions.Raise
static bool Raise(this EventHandler EventHandler, IObservableLayer Sender, bool Decoupled)
Raises an event, if handler is defined. Any exceptions are trapped and logged.
Definition: EventHandlerExtensions.cs:201
Waher.Events.EventHandlerExtensions.Raise
static async Task< bool > Raise(this EventHandlerAsync EventHandler, IObservableLayer Sender, EventArgs e, bool Decoupled)
Raises an event, if handler is defined. Any exceptions are trapped and logged.
Definition: EventHandlerExtensions.cs:556
Waher.Events.EventHandlerExtensions.Raise
static bool Raise(this EventHandler EventHandler, object Sender, EventArgs e, bool Decoupled)
Raises an event, if handler is defined. Any exceptions are trapped and logged.
Definition: EventHandlerExtensions.cs:87
Waher.Events.EventHandlerExtensions.Call< ArgT >
static void Call< ArgT >(this Callback< ArgT > Callback, ArgT Argument)
Calls a callback function. Any exceptions are trapped and logged.
Definition: EventHandlerExtensions.cs:684
Waher.Events.EventHandlerExtensions.Raise
static Task< bool > Raise(this EventHandlerAsync EventHandler, IObservableLayer Sender, bool Decoupled)
Raises an event, if handler is defined. Any exceptions are trapped and logged.
Definition: EventHandlerExtensions.cs:530
Waher.Events.EventHandlerExtensions.Raise
static async Task< bool > Raise(this EventHandlerAsync EventHandler, object Sender, EventArgs e, bool Decoupled)
Raises an event, if handler is defined. Any exceptions are trapped and logged.
Definition: EventHandlerExtensions.cs:416
Waher.Events.EventHandlerExtensions.Raise
static bool Raise(this EventHandler EventHandler, IObservableLayer Sender, EventArgs e)
Raises an event, if handler is defined. Any exceptions are trapped and logged.
Definition: EventHandlerExtensions.cs:213
Waher.Events.EventHandlerExtensions.Raise
static Task< bool > Raise(this EventHandlerAsync EventHandler, object Sender, bool Decoupled)
Raises an event, if handler is defined. Any exceptions are trapped and logged.
Definition: EventHandlerExtensions.cs:390
Waher.Events.EventHandlerExtensions.Raise
static bool Raise(this EventHandler EventHandler, object Sender)
Raises an event, if handler is defined. Any exceptions are trapped and logged.
Definition: EventHandlerExtensions.cs:48
Waher.Events.EventHandlerExtensions.Raise
static bool Raise(this EventHandler EventHandler, object Sender, bool Decoupled)
Raises an event, if handler is defined. Any exceptions are trapped and logged.
Definition: EventHandlerExtensions.cs:61
Waher.Events.EventHandlerExtensions.Raise
static Task< bool > Raise(this EventHandlerAsync EventHandler, IObservableLayer Sender, EventArgs e)
Raises an event, if handler is defined. Any exceptions are trapped and logged.
Definition: EventHandlerExtensions.cs:542
Waher.Events.EventHandlerExtensions.Raise
static bool Raise(this EventHandler EventHandler, IObservableLayer Sender, EventArgs e, bool Decoupled)
Raises an event, if handler is defined. Any exceptions are trapped and logged.
Definition: EventHandlerExtensions.cs:227
Waher.Events.Log
Static class managing the application event log. Applications and services log events on this static ...
Definition: Log.cs:14
Waher.Events.Log.Exception
static void Exception(Exception Exception, string Object, string Actor, string EventId, EventLevel Level, string Facility, string Module, params KeyValuePair< string, object >[] Tags)
Logs an exception. Event type will be determined by the severity of the exception.
Definition: Log.cs:1657
Waher.Events.IObservableLayer
Interface for classes that can be observed.
Definition: IObservableLayer.cs:9
Waher.Events.IObservableLayer.Exception
void Exception(string Exception)
Called to inform the viewer of an exception state.
Waher.Events.IObservableLayer.DecoupledEvents
bool DecoupledEvents
If events raised from the communication layer are decoupled, i.e. executed in parallel with the sourc...
Definition: IObservableLayer.cs:14
Waher.Events.IObservableLayer.Warning
void Warning(string Warning)
Called to inform the viewer of a warning state.
_
Definition: ImplTypes.g.cs:58
Waher.Events.CallbackAsync< in T >
delegate Task CallbackAsync< in T >(T Arg)
Asynchronous callback function with one argument.
Waher.Events.EventHandlerAsync< in T >
delegate Task EventHandlerAsync< in T >(object Sender, T e)
Asynchronous version of EventArgs with a typed event arguments.
Waher.Events.EventHandlerAsync
delegate Task EventHandlerAsync(object Sender, EventArgs e)
Asynchronous version of EventArgs.
Waher.Events.Callback< in T >
delegate void Callback< in T >(T Arg)
Callback function with one argument.