public static void NotifyOrThrow(this ExceptionNotificationHandler handler, object source, ExceptionNotification args)
{
if (handler != null)
{
handler(source, args);
}
else if (args.Severity == ExceptionSeverity.Error)
{
throw args.Exception;
}
}
private PocoElementNode(Base instance, PocoElementNode parent, IElementDefinitionSummary definition, string location, string shortPath)
{
Current = instance;
_mySD = new Lazy <PocoComplexTypeSerializationInfo>(() => (PocoComplexTypeSerializationInfo)PocoStructureDefinitionSummaryProvider.Provide(Current.GetType()));
InstanceType = determineInstanceType(Current, definition);
Definition = definition ?? throw Error.ArgumentNull(nameof(definition));
ExceptionHandler = parent.ExceptionHandler;
Location = location;
ShortPath = shortPath;
}
private PocoElementNode(object instance, PocoElementNode parent, string location, string shortPath, int arrayIndex,
IElementDefinitionSummary summary)
{
Current = instance;
InstanceType = determineInstanceType(instance, summary);
Provider = parent.Provider;
ExceptionHandler = parent.ExceptionHandler;
Definition = summary;
Location = location;
ShortPath = shortPath;
ArrayIndex = arrayIndex;
Provider = parent.Provider;
}
/// <summary>
/// Registers an <see cref="ExceptionNotificationHandler" /> with an <see cref="IExceptionSource"/>.
/// </summary>
/// <seealso cref="ExceptionSourceExtensions.Catch(IExceptionSource, ExceptionNotificationHandler, bool)"/>
public static IDisposable Catch(this ISourceNode node, ExceptionNotificationHandler handler, bool forward = false)
{
if (node == null)
{
throw Error.ArgumentNull(nameof(node));
}
if (handler == null)
{
throw Error.ArgumentNull(nameof(handler));
}
return(node is IExceptionSource s?
s.Catch(handler, forward)
: throw new NotImplementedException("Node does not implement IExceptionSource."));
}
private PocoElementNode(ModelInspector inspector, Base instance, PocoElementNode parent, PropertyMapping definition, string location, string shortPath)
{
Current = instance;
_inspector = inspector;
var instanceType = determineInstanceType(instance.GetType(), definition);
_myClassMapping = _inspector.ImportType(instanceType);
InstanceType = ((IStructureDefinitionSummary)_myClassMapping).TypeName;
Definition = definition ?? throw Error.ArgumentNull(nameof(definition));
ExceptionHandler = parent.ExceptionHandler;
Location = location;
ShortPath = shortPath;
}
public ExceptionInterceptor(IExceptionSource source, ExceptionNotificationHandler handler, bool forward)
{
_source = source;
_originalHandler = source.ExceptionHandler;
source.ExceptionHandler = nestedHandler;
_forward = forward;
void nestedHandler(object s, ExceptionNotification a)
{
handler(s, a);
if (forward)
{
_originalHandler.NotifyOrThrow(s, a);
}
}
}
/// <summary>
/// Registers an <see cref="ExceptionNotificationHandler" /> with an <see cref="IExceptionSource"/>.
/// </summary>
/// <param name="source"></param>
/// <param name="handler"></param>
/// <param name="forward">If true, also forwards the error to the original handler (if any).</param>
/// <returns>An object that, when disposed, unregisters the handler from the source.</returns>
/// <remarks>
/// <para>This function can be used directly inside a <c>using</c> block, to scope the interception
/// of exceptions by the given handler to that block.</para>
/// <para>The <paramref name="handler"/> replaces the handler already in place in the source (of any), but
/// as soon as executing leaves the block, the handler is unregistered, and the original handler restored.</para>
/// <para>If the source originally had a handler set, the <paramref name="forward"/> can be used to forward
/// the exception to the original handler, after invoking the handler passed in with <paramref name="handler"/>.</para>
/// </remarks>
/// <example>
/// <code>
/// using(source.Catch((o,a) => lastError = a))
/// {
/// var children = source.Children();
/// }
/// </code></example>
public static IDisposable Catch(this IExceptionSource source, ExceptionNotificationHandler handler, bool forward = false) =>
new ExceptionInterceptor(source, handler, forward);
protected BaseController(INotificationHandler <ExceptionNotification> notifications)
{
_notifications = (ExceptionNotificationHandler)notifications;
}
protected CommandHandler(INotificationHandler <ExceptionNotification> notifications, IMediator bus, IUnitOfWork uow = null)
{
_uow = uow;
_notifications = (ExceptionNotificationHandler)notifications;
_bus = bus;
}
public static IDisposable Catch(this ITypedElement source, ExceptionNotificationHandler handler) =>
source is IExceptionSource s?s.Catch(handler) : throw new NotImplementedException("Element does not implement IExceptionSource.");
