Example: Report and swallow exceptions
Report and swallow is a last-chance exception-handling strategy, i.e. a strategy for exceptions that could not be handled deeper in the call stack. In general, swallowing a last-chance exception is not a good idea because it may leave your application in an invalid state. Also, using an aspect to implement a last-chance exception handler is generally not a good idea because it is simpler to use the AppDomain.CurrentDomain.UnhandledException event.
However, there are some cases where you need to handle last-chance exceptions with a try...catch
block. For instance,
when your code is a plug-in in some host application like Office or Visual Studio, exceptions that are not handled by
Visual Studio Extensions have a chance to crash the whole Visual Studio without any error message.
In this case, you must implement exception handling at each entry point of your API. This includes:
- any interface of the host that your plug-in implements,
- any handlers to host events your plug-in subscribes to,
- any Winforms/WPF entry point.
Since there can be hundreds of such entry points, it is useful to automate this pattern using an aspect.
In this example, we will assume that we have a host application that defines an interface IPartProvider
that plug-ins
can implement. Let's see what the aspect does with the code:
1public class PartProvider : IPartProvider
2{
3 [ReportAndSwallowExceptions]
4 public string GetPart( string name ) => throw new Exception( "This method has a bug." );
5}
1using System;
2
3public class PartProvider : IPartProvider
4{
5 [ReportAndSwallowExceptions]
6 public string GetPart( string name ) { try
7 {
8 throw new Exception( "This method has a bug." );}
9 catch (Exception e) when (_exceptionHandler != null && _exceptionHandler.ShouldHandle(e))
10 {
11 _exceptionHandler.Report(e);
12 return default;
13 }
14 }
15private ILastChanceExceptionHandler? _exceptionHandler;
16
17 public PartProvider(ILastChanceExceptionHandler? exceptionHandler = default(global::ILastChanceExceptionHandler?))
18 {
19 this._exceptionHandler = exceptionHandler;
20 }
21}
As we can see, the ReportAndSwallowExceptions
aspect pulls the ILastChanceExceptionHandler
from the dependency
injection container and adds a try...catch
block to the target method.
Infrastructure code
The aspect uses the following interface:
1public interface ILastChanceExceptionHandler
2{
3 /// <summary>
4 /// Determines if an exception should be handled. Typically returns <c>false</c>
5 /// for exception like <see cref="OperationCanceledException"/>.
6 /// </summary>
7 bool ShouldHandle( Exception e );
8
9 /// <summary>
10 /// Reports the exception to the user or to the crash report service.
11 /// </summary>
12 void Report( Exception e );
13}
Aspect code
The ReportAndSwallowExceptionsAttribute
aspect is rather simple:
1using Metalama.Extensions.DependencyInjection;
2using Metalama.Framework.Aspects;
3
4#pragma warning disable CS0649
5
6public class ReportAndSwallowExceptionsAttribute : OverrideMethodAspect
7{
8 [IntroduceDependency( IsRequired = false )]
9 private readonly ILastChanceExceptionHandler? _exceptionHandler;
10
11 public override dynamic? OverrideMethod()
12 {
13 try
14 {
15 return meta.Proceed();
16 }
17 catch ( Exception e ) when ( this._exceptionHandler != null &&
18 this._exceptionHandler.ShouldHandle( e ) )
19 {
20 this._exceptionHandler.Report( e );
21
22 return default;
23 }
24 }
25}
If you have read the previous examples, the following notes should be redundant.
The ReportAndSwallowExceptionsAttribute
class derives from the OverrideMethodAspect
abstract class, which in turn derives from the System.Attribute class. This
makes ReportAndSwallowExceptionsAttribute
a custom attribute.
The ReportAndSwallowExceptionsAttribute
class implements
the OverrideMethod method. This method acts like a template.
Most of the code in this template is injected into the target method, i.e., the method to which we add
the [ReportAndSwallowExceptionsAttribute]
custom attribute.
Inside the OverrideMethod implementation, the call
to meta.Proceed()
has a very special meaning. When the aspect is applied to the target, the call to meta.Proceed()
is replaced by the original implementation, with a few syntactic changes to capture the return value.
To remind you that meta.Proceed()
has a special meaning, it is colored differently than the rest of the code. If you
use Metalama Tools for Visual Studio, you will also enjoy syntax highlighting in this IDE.
Around the call to meta.Proceed()
, we have a try...catch
exception handler. The catch
block has a when
clause
that should ensure that we do not handle exceptions that are accepted by the host,
typically OperationCanceledException. Then, the catch
handler simply reports the exception and does not
rethrow it.
The [IntroduceDependency] on the top of
the _exceptionHandler
field does the magic of introducing the field and pulling it from the constructor.