如何获取特定方法执行期间所有调用方法的执行时长（含PostSharp实现）

Great question! Tracking the execution time of all methods called within a specific method is incredibly valuable for profiling bottlenecks and optimizing code. Let’s break this down—first the general approach, then a clean implementation using PostSharp.

Before diving into PostSharp, here’s the core logic you’d need regardless of the tool:

• Intercept method entry and exit: Record the start time when a method begins, then calculate elapsed time when it finishes.
• Track call context: Identify when we’re inside the scope of your target method, so we only log calls that happen within that chain.
• Collect and visualize data: Store execution times for each method, then aggregate and display the results (e.g., total time, average time, call count).

PostSharp is an excellent AOP (Aspect-Oriented Programming) framework that lets you add cross-cutting concerns like performance tracking without cluttering your business code. Here’s how to set it up:

Step 1: Create a Thread-Safe Tracking Context #

We need a way to track whether we’re inside the target method’s call stack, and store execution times. Using [ThreadStatic] ensures thread safety since each thread’s call chain is independent:

public static class MethodTrackingContext
{
    [ThreadStatic]
    private static int _trackingDepth;

    public static bool IsTracking => _trackingDepth > 0;

    public static void StartTracking() => _trackingDepth++;

    public static void StopTracking() => _trackingDepth--;

    public static Dictionary<string, List<long>> MethodExecutionTimes { get; } = new Dictionary<string, List<long>>();
}

Step 2: Create a Marker Attribute for Target Methods #

This attribute marks the specific method whose child calls you want to track:

[AttributeUsage(AttributeTargets.Method)]
public class TrackChildMethodsAttribute : Attribute { }

Step 3: Build the Execution Time Aspect #

This is the core of the implementation—an aspect that intercepts method calls to measure time, but only when inside the target method’s context:

[Serializable]
public class MethodExecutionTimeAspect : OnMethodBoundaryAspect
{
    public override void OnEntry(MethodExecutionArgs args)
    {
        // Check if we're either entering the target method or already tracking its child calls
        var isTargetMethod = args.Method.GetCustomAttribute<TrackChildMethodsAttribute>() != null;
        if (isTargetMethod || MethodTrackingContext.IsTracking)
        {
            if (isTargetMethod)
            {
                MethodTrackingContext.StartTracking();
                Console.WriteLine($"Started tracking target method: {args.Method.Name}");
            }
            // Store the start time in the method execution args
            args.MethodExecutionTag = Stopwatch.StartNew();
        }
    }

    public override void OnExit(MethodExecutionArgs args)
    {
        if (!(args.MethodExecutionTag is Stopwatch stopwatch)) return;

        stopwatch.Stop();
        var methodFullName = $"{args.Method.DeclaringType.FullName}.{args.Method.Name}";
        var elapsedMs = stopwatch.ElapsedMilliseconds;

        // Collect the execution time
        if (!MethodTrackingContext.MethodExecutionTimes.ContainsKey(methodFullName))
        {
            MethodTrackingContext.MethodExecutionTimes[methodFullName] = new List<long>();
        }
        MethodTrackingContext.MethodExecutionTimes[methodFullName].Add(elapsedMs);

        Console.WriteLine($"Method {methodFullName} executed in {elapsedMs}ms");

        // If exiting the target method, output a summary and reset tracking
        var isTargetMethod = args.Method.GetCustomAttribute<TrackChildMethodsAttribute>() != null;
        if (isTargetMethod)
        {
            MethodTrackingContext.StopTracking();
            Console.WriteLine("\n===== Target Method Call Chain Summary =====");
            foreach (var kvp in MethodTrackingContext.MethodExecutionTimes)
            {
                var averageMs = kvp.Value.Average();
                Console.WriteLine($"{kvp.Key}: Calls={kvp.Value.Count}, Avg={averageMs:F2}ms, Total={kvp.Value.Sum()}ms");
            }
            // Clear data to avoid interfering with future calls
            MethodTrackingContext.MethodExecutionTimes.Clear();
        }
    }
}

Step 4: Apply the Aspect and Marker #

Option 1: Global Aspect Registration #

Apply the aspect to all methods in your namespace (add this to AssemblyInfo.cs):

[assembly: MethodExecutionTimeAspect(AttributeTargetTypes = "YourAppNamespace.*")]

Option 2: Mark Your Target Method #

Add the [TrackChildMethods] attribute to the method you want to monitor:

public class OrderProcessor
{
    [TrackChildMethods]
    public void ProcessCustomerOrder()
    {
        ValidateOrderDetails();
        CalculateOrderTotal();
        SaveOrderToDatabase();
    }

    private void ValidateOrderDetails()
    {
        // Simulate work
        Thread.Sleep(120);
    }

    private void CalculateOrderTotal()
    {
        Thread.Sleep(75);
    }

    private void SaveOrderToDatabase()
    {
        Thread.Sleep(250);
    }
}

Handling Async Methods #

If your code uses async/await, you’ll need a slightly modified aspect that supports asynchronous methods:

[Serializable]
public class AsyncMethodExecutionTimeAspect : OnAsyncMethodBoundaryAspect
{
    private Stopwatch _stopwatch;

    public override void OnEntry(MethodExecutionArgs args)
    {
        var isTargetMethod = args.Method.GetCustomAttribute<TrackChildMethodsAttribute>() != null;
        if (isTargetMethod || MethodTrackingContext.IsTracking)
        {
            if (isTargetMethod)
            {
                MethodTrackingContext.StartTracking();
            }
            _stopwatch = Stopwatch.StartNew();
        }
    }

    public override async Task OnExitAsync(MethodExecutionArgs args)
    {
        if (_stopwatch == null) return;

        _stopwatch.Stop();
        var methodFullName = $"{args.Method.DeclaringType.FullName}.{args.Method.Name}";
        var elapsedMs = _stopwatch.ElapsedMilliseconds;

        // Collect data same as before
        if (!MethodTrackingContext.MethodExecutionTimes.ContainsKey(methodFullName))
        {
            MethodTrackingContext.MethodExecutionTimes[methodFullName] = new List<long>();
        }
        MethodTrackingContext.MethodExecutionTimes[methodFullName].Add(elapsedMs);

        Console.WriteLine($"Async method {methodFullName} executed in {elapsedMs}ms");

        var isTargetMethod = args.Method.GetCustomAttribute<TrackChildMethodsAttribute>() != null;
        if (isTargetMethod)
        {
            MethodTrackingContext.StopTracking();
            // Output summary...
            MethodTrackingContext.MethodExecutionTimes.Clear();
        }

        await Task.CompletedTask;
    }
}

Key Notes #

• Thread Safety: The [ThreadStatic] field ensures tracking doesn’t leak between threads (critical for web apps or multi-threaded services).
• Performance Overhead: AOP adds minimal overhead, but it’s best to enable this only in profiling/debug environments, not production.
• Non-Intrusive: Your business code stays clean—all tracking logic lives in the aspect.

内容的提问来源于stack exchange，提问作者Jay Shah