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<T>(object Sender, T e);
18
24 public delegate void Callback<ArgT>(ArgT Arg);
25
31 public delegate Task CallbackAsync<ArgT>(ArgT 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 Task<bool> Raise(this EventHandler EventHandler, IObservableLayer Sender)
189 {
190 return Raise(EventHandler, Sender, EventArgs.Empty, Sender?.DecoupledEvents ?? false);
191 }
192
201 public static Task<bool> Raise(this EventHandler EventHandler, IObservableLayer Sender, bool Decoupled)
202 {
203 return Raise(EventHandler, Sender, EventArgs.Empty, Decoupled);
204 }
205
213 public static Task<bool> Raise(this EventHandler EventHandler, IObservableLayer Sender, EventArgs e)
214 {
215 return EventHandler.Raise(Sender, e, Sender?.DecoupledEvents ?? false);
216 }
217
227 public static async Task<bool> Raise(this EventHandler EventHandler, IObservableLayer Sender, EventArgs e, bool Decoupled)
228 {
229 if (EventHandler is null)
230 await Sender.NoEventHandlerWarning(e);
231 else if (Decoupled)
232 {
233 Task _ = Task.Run(async () =>
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 await 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
269 if (!(Sender is null))
270 await Sender.Exception(ex);
271
272 return false;
273 }
274 }
275
276 return true;
277 }
278
284 private static Task NoEventHandlerWarning(this IObservableLayer Sender, object e)
285 {
286 if (Sender is null)
287 return Task.CompletedTask;
288
289 StringBuilder sb = new StringBuilder();
290
291 sb.Append("No event handler registered (");
292
293 if (Sender is null)
294 sb.Append("null sender");
295 else
296 sb.Append(Sender.GetType().FullName);
297
298 sb.Append(", ");
299 sb.Append(e.GetType().FullName);
300 sb.Append(")");
301
302 return Sender.Warning(sb.ToString());
303 }
304
312 public static Task<bool> Raise<T>(this EventHandler<T> EventHandler, IObservableLayer Sender, T e)
313 {
314 return EventHandler.Raise(Sender, e, Sender?.DecoupledEvents ?? false);
315 }
316
326 public static async Task<bool> Raise<T>(this EventHandler<T> EventHandler, IObservableLayer Sender, T e, bool Decoupled)
327 {
328 if (EventHandler is null)
329 await Sender.NoEventHandlerWarning(e);
330 else if (Decoupled)
331 {
332 Task _ = Task.Run(async () =>
333 {
334 try
335 {
336 EventHandler(Sender, e);
337 }
338 catch (Exception ex)
339 {
340 Log.Exception(ex);
341
342 if (!(Sender is null))
343 {
344 try
345 {
346 await Sender.Exception(ex);
347 }
348 catch (Exception ex2)
349 {
350 Log.Exception(ex2);
351 }
352 }
353 }
354 });
355
356 return true;
357 }
358 else
359 {
360 try
361 {
362 EventHandler(Sender, e);
363 }
364 catch (Exception ex)
365 {
366 Log.Exception(ex);
367
368 if (!(Sender is null))
369 await Sender.Exception(ex);
370
371 return false;
372 }
373 }
374
375 return true;
376 }
377
378 #endregion
379
380 #region Asynchronous event handlers, non-communication-layers
381
388 public static Task<bool> Raise(this EventHandlerAsync EventHandler, object Sender)
389 {
390 return Raise(EventHandler, Sender, EventArgs.Empty, false);
391 }
392
401 public static Task<bool> Raise(this EventHandlerAsync EventHandler, object Sender, bool Decoupled)
402 {
403 return Raise(EventHandler, Sender, EventArgs.Empty, Decoupled);
404 }
405
413 public static Task<bool> Raise(this EventHandlerAsync EventHandler, object Sender, EventArgs e)
414 {
415 return EventHandler.Raise(Sender, e, false);
416 }
417
427 public static async Task<bool> Raise(this EventHandlerAsync EventHandler, object Sender, EventArgs e, bool Decoupled)
428 {
429 if (!(EventHandler is null))
430 {
431 if (Decoupled)
432 {
433 Task _ = Task.Run(async () =>
434 {
435 try
436 {
437 await EventHandler(Sender, e);
438 }
439 catch (Exception ex)
440 {
441 Log.Exception(ex);
442 }
443 });
444 }
445 else
446 {
447 try
448 {
449 await EventHandler(Sender, e);
450 }
451 catch (Exception ex)
452 {
453 Log.Exception(ex);
454 return false;
455 }
456 }
457 }
458
459 return true;
460 }
461
469 public static Task<bool> Raise<T>(this EventHandlerAsync<T> EventHandler, object Sender, T e)
470 {
471 return EventHandler.Raise(Sender, e, false);
472 }
473
483 public static async Task<bool> Raise<T>(this EventHandlerAsync<T> EventHandler, object Sender, T e, bool Decoupled)
484 {
485 if (!(EventHandler is null))
486 {
487 if (Decoupled)
488 {
489 Task _ = Task.Run(async () =>
490 {
491 try
492 {
493 await EventHandler(Sender, e);
494 }
495 catch (Exception ex)
496 {
497 Log.Exception(ex);
498 }
499 });
500 }
501 else
502 {
503 try
504 {
505 await EventHandler(Sender, e);
506 }
507 catch (Exception ex)
508 {
509 Log.Exception(ex);
510 return false;
511 }
512 }
513 }
514
515 return true;
516 }
517
518 #endregion
519
520 #region Asynchronous event handlers, communication layers
521
528 public static Task<bool> Raise(this EventHandlerAsync EventHandler, IObservableLayer Sender)
529 {
530 return Raise(EventHandler, Sender, EventArgs.Empty, Sender?.DecoupledEvents ?? false);
531 }
532
541 public static Task<bool> Raise(this EventHandlerAsync EventHandler, IObservableLayer Sender, bool Decoupled)
542 {
543 return Raise(EventHandler, Sender, EventArgs.Empty, Decoupled);
544 }
545
553 public static Task<bool> Raise(this EventHandlerAsync EventHandler, IObservableLayer Sender, EventArgs e)
554 {
555 return EventHandler.Raise(Sender, e, Sender?.DecoupledEvents ?? false);
556 }
557
567 public static async Task<bool> Raise(this EventHandlerAsync EventHandler, IObservableLayer Sender, EventArgs e, bool Decoupled)
568 {
569 if (EventHandler is null)
570 await Sender.NoEventHandlerWarning(e);
571 else if (Decoupled)
572 {
573 Task _ = Task.Run(async () =>
574 {
575 try
576 {
577 await EventHandler(Sender, e);
578 }
579 catch (Exception ex)
580 {
581 Log.Exception(ex);
582
583 if (!(Sender is null))
584 {
585 try
586 {
587 await Sender.Exception(ex);
588 }
589 catch (Exception ex2)
590 {
591 Log.Exception(ex2);
592 }
593 }
594 }
595 });
596
597 return true;
598 }
599 else
600 {
601 try
602 {
603 await EventHandler(Sender, e);
604 }
605 catch (Exception ex)
606 {
607 Log.Exception(ex);
608
609 if (!(Sender is null))
610 await Sender.Exception(ex);
611
612 return false;
613 }
614 }
615
616 return true;
617 }
618
626 public static Task<bool> Raise<T>(this EventHandlerAsync<T> EventHandler, IObservableLayer Sender, T e)
627 {
628 return EventHandler.Raise(Sender, e, Sender?.DecoupledEvents ?? false);
629 }
630
640 public static async Task<bool> Raise<T>(this EventHandlerAsync<T> EventHandler, IObservableLayer Sender, T e, bool Decoupled)
641 {
642 if (EventHandler is null)
643 await Sender.NoEventHandlerWarning(e);
644 else if (Decoupled)
645 {
646 Task _ = Task.Run(async () =>
647 {
648 try
649 {
650 await EventHandler(Sender, e);
651 }
652 catch (Exception ex)
653 {
654 Log.Exception(ex);
655
656 if (!(Sender is null))
657 {
658 try
659 {
660 await Sender.Exception(ex);
661 }
662 catch (Exception ex2)
663 {
664 Log.Exception(ex2);
665 }
666 }
667 }
668 });
669
670 return true;
671 }
672 else
673 {
674 try
675 {
676 await EventHandler(Sender, e);
677 }
678 catch (Exception ex)
679 {
680 Log.Exception(ex);
681
682 if (!(Sender is null))
683 await Sender.Exception(ex);
684
685 return false;
686 }
687 }
688
689 return true;
690 }
691
692 #endregion
693
694 #region Synchronous callback functions
695
701 public static void Call<ArgT>(this Callback<ArgT> Callback, ArgT Argument)
702 {
703 if (!(Callback is null))
704 {
705 try
706 {
707 Callback(Argument);
708 }
709 catch (Exception ex)
710 {
711 Log.Exception(ex);
712 }
713 }
714 }
715
716 #endregion
717
718 #region Asynchronous callback functions
719
725 public static async Task Call<ArgT>(this CallbackAsync<ArgT> Callback, ArgT Argument)
726 {
727 if (!(Callback is null))
728 {
729 try
730 {
731 await Callback(Argument);
732 }
733 catch (Exception ex)
734 {
735 Log.Exception(ex);
736 }
737 }
738 }
739
740 #endregion
741 }
742}
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:413
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:388
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
static Task< 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< 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:528
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:567
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:701
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:541
Waher.Events.EventHandlerExtensions.Raise
static async Task< 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.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:427
Waher.Events.EventHandlerExtensions.Raise
static Task< 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 Task< 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:401
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:553
Waher.Events.Log
Static class managing the application event log. Applications and services log events on this static ...
Definition: Log.cs:13
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:1647
Waher.Events.IObservableLayer
Interface for classes that can be observed.
Definition: IObservableLayer.cs:10
Waher.Events.IObservableLayer.Warning
Task Warning(string Warning)
Called to inform the viewer of a warning state.
Waher.Events.IObservableLayer.Exception
Task 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:15
Waher.Events.EventHandlerAsync
delegate Task EventHandlerAsync(object Sender, EventArgs e)
Asynchronous version of EventArgs.
Waher.Events.EventHandlerAsync< T >
delegate Task EventHandlerAsync< T >(object Sender, T e)
Asynchronous version of EventArgs with a typed event arguments.
Waher.Events.Callback< ArgT >
delegate void Callback< ArgT >(ArgT Arg)
Callback function with one argument.
Waher.Events.CallbackAsync< ArgT >
delegate Task CallbackAsync< ArgT >(ArgT Arg)
Asynchronous callback function with one argument.