MethodBoundaryAspect.Fody

When applying aspects to async methods, note the following lifecycle differences:

1. OnEntry: Runs on the main thread when the method is first called.
2. OnExit: Runs when the method returns its Task to the caller, not necessarily when the asynchronous work completes. To run code when the work actually finishes, use task.ContinueWith inside OnExit.
3. OnException: Triggered if the method throws, returns null (causing a NullReferenceException on await), or returns a faulted task. This may occur long after OnExit has run.

Tip: Because OnExit and OnException can overlap or run in unexpected orders in async contexts, use MethodExecutionTag to track if OnExit has already executed to avoid duplicate logic in OnException.

// Pattern to ensure OnException only runs if OnExit hasn't
public sealed class LogAttribute : OnMethodBoundaryAspect
{
    public override void OnEntry(MethodExecutionArgs args)
    {
        args.MethodExecutionTag = false;
    }

    public override void OnExit(MethodExecutionArgs args)
    {
        args.MethodExecutionTag = true;
    }

    public override void OnException(MethodExecutionArgs args)
    {
        if ((bool)args.MethodExecutionTag) return;
        // Handle exception...
    }
}

To create an aspect, inherit from OnMethodBoundaryAspect and override the lifecycle methods: OnEntry, OnExit, and OnException. You use the MethodExecutionArgs object to access method details and state.

Example of a transaction aspect that uses MethodExecutionTag to pass state between entry and exit:

using MethodBoundaryAspect.Fody.Attributes;

public sealed class TransactionScopeAttribute : OnMethodBoundaryAspect
{
    public override void OnEntry(MethodExecutionArgs args)
    {
        // Set a custom object to be accessed later
        args.MethodExecutionTag = new TransactionScope();
    }

    public override void OnExit(MethodExecutionArgs args)
    {
        var transactionScope = (TransactionScope)args.MethodExecutionTag;
        transactionScope.Complete();
        transactionScope.Dispose();
    }

    public override void OnException(MethodExecutionArgs args)
    {
        var transactionScope = (TransactionScope)args.MethodExecutionTag;
        transactionScope.Dispose();
    }
}

You can overwrite the return value of a method by setting the ReturnValue property of MethodExecutionArgs within the OnExit handler. This works for both synchronous and asynchronous methods.

For asynchronous methods, you can intercept the returned Task to perform additional processing or exception handling using ContinueWith.

using MethodBoundaryAspect.Fody.Attributes;
using System;
using System.Linq;
using static System.Console;

public sealed class IndentAttribute : OnMethodBoundaryAspect
{
    public override void OnExit(MethodExecutionArgs args)
    {
        // Overwrite the return value
        args.ReturnValue = String.Concat(args.ReturnValue.ToString().Split('\n').Select(line => "  " + line));
    }
}

public class Program
{
    [Indent]
    public static string GetLogs() => @"Detailed Log 1
Detailed Log 2";

    public static void Main(string[] args)
    {
        WriteLine(GetLogs()); // Output: "  Detailed Log 1\n  Detailed Log 2";
    }
}