Debugging aspect-oriented code

In this section, we will demonstrate how to debug aspect-oriented code using the Visual Studio debugger. This follows on from our previous discussion on how aspects transform your code, which included a side-by-side comparison of the original and transformed code at Metalama Diff.

Steps to debug aspect-oriented code

To debug your code with aspects, follow these steps:

Step 1: Open Build Configuration Manager

From the debug setting dropdown, select Configuration Manager as shown below:

Step 2: Create a debug configuration called LamaDebug

The Configuration Manager will display the following dialog:

• Open the Active solution configuration dropdown.

• Click on <New...> to create a new debug configuration. This action will open the New dialog as shown below.

• Enter the name LamaDebug and copy settings from Debug as indicated below.

• Save this configuration by clicking the OK button.
• Change the build configuration to LamaDebug.

You are now ready to debug your aspect-transformed code.

Breakpoints and Step-Into

If you set a breakpoint in your code that is being modified by an aspect, those breakpoints will not be hit. However, you can use F11 to Step-Into as usual.

You can also set breakpoints in the transformed code. In the following sections, we will guide you on how to locate the transformed code and how to debug it.

Consider the following code with the logging ([Log]) aspect:

The logging aspect adds a line at the beginning of the method it intercepts, indicating the name of the intercepted method. When you step into this code by pressing F11, you should see the transformed code as shown.

To locate the transformed code, click on the Show all files button as shown below.

Once all files in your solution explorer are displayed, locate the file under LamaDebug\net6.0\metalama as shown in the solution explorer screenshot below.

As demonstrated, you can set a breakpoint on this transformed code, and it will be hit because this is the compiled code.

Debugging using step-in and forceful break

1// See https://aka.ms/new-console-template for more information
2
3using Metalama.Documentation.QuickStart;
4using System.Diagnostics;

5namespace DebugDemo
6{
7    public class Demo
8    {
9        public static void Main()
10        {
11            Debugger.Break();

12            DoThis();
13        }

14
15        [Log]
16        public static void DoThis()
17        {
18            Console.WriteLine("Doing this");

19            DoThat();
20        }

21        [Log]
22        public static void DoThat()
23        {
24            Console.WriteLine("Doing that");

25        }

26    }
27}
28

1// See https://aka.ms/new-console-template for more information
2
3using Metalama.Documentation.QuickStart;
4using System;
5using System.Diagnostics;
6namespace DebugDemo
7{
8    public class Demo
9    {
10        public static void Main()
11        {
12            Console.WriteLine("Executing Demo.Main().");
13            Debugger.Break();
14            DoThis();
15            return;
16        }
17
18        [Log]
19        public static void DoThis()
20        {
21            Console.WriteLine("Executing Demo.DoThis().");
22            Console.WriteLine("Doing this");
23            DoThat();
24            return;
25        }
26        [Log]
27        public static void DoThat()
28        {
29            Console.WriteLine("Executing Demo.DoThat().");
30            Console.WriteLine("Doing that");
31            return;
32        }
33    }
34}
35

Breaking forcefully using Debugger.Break

You can use Debugger.Break to forcefully break the program. The following screenshot illustrates its usage.