如何在被拦截方法获取AspectContext对象呢？

[xiazhaozhao]

代码如下:
` public async override Task Invoke(AspectContext context, AspectDelegate next)
{
try
{
Console.WriteLine("Before service call");
context.AdditionalData.Add("CustomData", "CustomValue");

     await next(context);
 }
 catch (Exception)
 {
     Console.WriteLine("Service threw an exception!");
     throw;
 }
 finally
 {
     Console.WriteLine("After service call");
 }

}` 如何在被拦截方法中获取到AspectContext 对象内的AdditionalData字典数据呢？

[huoshan12345]

可以考虑用AsyncLocal

[xiazhaozhao]

这是来自QQ邮箱的假期自动回复邮件。   您好，我最近正在休假中，无法亲自回复您的邮件。我将在假期结束后，尽快给您回复。

[liuhaoyang]

解决方案

要在被拦截方法内部获取 AspectContext 的 AdditionalData 数据，可以使用 来在异步调用上下文中传递数据。

示例代码

原理说明

1. AsyncLocal 是 .NET 提供的线程局部存储，能够随异步调用链自动流转
2. 拦截器在执行 时，会把当前 存储到
3. 被拦截的方法执行时，可以通过 获取到 实例
4. 这样就能访问 中存储的数据了

注意事项

• 的值会自动沿着异步调用链传递，但在 之后会恢复原值
• 确保在 块中清理 ，避免内存泄漏
• 如果需要在多个拦截器间共享数据，这种方式很有效

---

另外，框架中有一个被注释掉的 类（在 包中），它内部也使用了 的模式。如果官方在未来重新启用这个功能，可能会提供更优雅的解决方案。

[liuhaoyang]

解决方案

要在被拦截方法内部获取 AspectContext 的 AdditionalData 数据，可以使用 AsyncLocal 来在异步调用上下文中传递数据。

示例代码

using System.Threading;
using AspectCore.DynamicProxy;

// 定义一个 AsyncLocal 来存储 AspectContext
public static class AspectContextAccessor
{
    public static readonly AsyncLocal<AspectContext> Current = new AsyncLocal<AspectContext>();
}

// 拦截器：在进入时设置 Context
public class CustomInterceptorAttribute : AbstractInterceptorAttribute
{
    public async override Task Invoke(AspectContext context, AspectDelegate next)
    {
        // 1. 设置当前 Context
        AspectContextAccessor.Current.Value = context;
        
        // 2. 设置 AdditionalData
        context.AdditionalData.Add("CustomData", "CustomValue");
        
        try
        {
            Console.WriteLine("Before service call");
            await next(context);
        }
        catch (Exception)
        {
            Console.WriteLine("Service threw an exception!");
            throw;
        }
        finally
        {
            Console.WriteLine("After service call");
            // 3. 清理（可选）
            AspectContextAccessor.Current.Value = null;
        }
    }
}

// 被拦截的服务类
public class MyService
{
    public void DoSomething()
    {
        // 4. 在被拦截方法中获取 AspectContext
        var context = AspectContextAccessor.Current.Value;
        
        if (context != null && context.AdditionalData.ContainsKey("CustomData"))
        {
            var customValue = context.AdditionalData["CustomData"] as string;
            Console.WriteLine($"Got custom value from aspect: {customValue}");
        }
    }
}

原理说明

1. AsyncLocal 是 .NET 提供的线程局部存储，能够随异步调用链自动流转
2. 拦截器在执行时，会把当前 AspectContext 存储到 AsyncLocal
3. 被拦截的方法执行时，可以通过 AsyncLocal 获取到 AspectContext 实例
4. 这样就能访问 AdditionalData 中存储的数据了

注意事项

• AsyncLocal 的值会自动沿着异步调用链传递
• 确保在 finally 块中清理 AsyncLocal，避免内存泄漏
• 如果需要在多个拦截器间共享数据，这种方式很有效

[xiazhaozhao]

这是来自QQ邮箱的假期自动回复邮件。   您好，我最近正在休假中，无法亲自回复您的邮件。我将在假期结束后，尽快给您回复。

[liuhaoyang]

解决方案：使用 AspectCore.Extensions.AspectScope 包

AspectCore Framework 提供了专门的扩展示包 来解决这个问题。

方法一：使用 IAspectScheduler 访问当前上下文

1. 引用包

<PackageReference Include="AspectCore.Extensions.AspectScope" Version="2.3.0" />

2. 注册服务

services.AddAspectScope();

3. 在拦截器中设置数据

public class CustomInterceptorAttribute : AbstractInterceptorAttribute
{
    public async override Task Invoke(AspectContext context, AspectDelegate next)
    {
        // 设置数据到 AdditionalData
        context.AdditionalData.Add("CustomData", "CustomValue");
        
        try
        {
            Console.WriteLine("Before service call");
            await next(context);
        }
        catch (Exception)
        {
            Console.WriteLine("Service threw an exception!");
            throw;
        }
        finally
        {
            Console.WriteLine("After service call");
        }
    }
}

4. 在被拦截方法中获取数据

public class MyService
{
    private readonly IServiceProvider _serviceProvider;
    
    public MyService(IServiceProvider serviceProvider)
    {
        _serviceProvider = serviceProvider;
    }
    
    public void DoSomething()
    {
        // 从服务提供者获取 IAspectScheduler
        var scheduler = _serviceProvider.GetService<IAspectScheduler>();
        
        if (scheduler != null)
        {
            // 获取当前的 AspectContext 链（可能有多个嵌套的上下文）
            var contexts = scheduler.GetCurrentContexts();
            
            // 获取最外层的上下文（通常是你想要的）
            if (contexts.Length > 0)
            {
                var currentContext = contexts[0];
                
                if (currentContext.AdditionalData.ContainsKey("CustomData"))
                {
                    var customValue = currentContext.AdditionalData["CustomData"] as string;
                    Console.WriteLine($"Got custom value from aspect: {customValue}");
                }
            }
        }
    }
}

---

方法二：使用 AsyncLocal（备选方案）

如果你不想使用 包，可以用 .NET 内置的 ：

using System.Threading;

// 定义一个静态访问器
public static class AspectContextAccessor
{
    public static readonly AsyncLocal<AspectContext> Current = new AsyncLocal<AspectContext>();
}

// 拦截器
public class CustomInterceptorAttribute : AbstractInterceptorAttribute
{
    public async override Task Invoke(AspectContext context, AspectDelegate next)
    {
        AspectContextAccessor.Current.Value = context;
        context.AdditionalData.Add("CustomData", "CustomValue");
        
        try
        {
            await next(context);
        }
        finally
        {
            AspectContextAccessor.Current.Value = null;
        }
    }
}

// 被拦截方法
public class MyService
{
    public void DoSomething()
    {
        var context = AspectContextAccessor.Current.Value;
        if (context?.AdditionalData.ContainsKey("CustomData") == true)
        {
            var value = context.AdditionalData["CustomData"] as string;
            Console.WriteLine($"Got: {value}");
        }
    }
}

---

推荐使用方法一（IAspectScheduler），因为它是框架官方提供的解决方案，更符合设计意图，而且可以正确处理嵌套调用场景。

[liuhaoyang]

在被拦截的方法内部获取 AspectContext 对象的数据，可以通过以下几种方式：

方式 1：使用静态上下文（推荐）

using AspectCore.DynamicProxy;

// 在拦截器中
public class MyInterceptor : Attribute, IAspectInterceptor
{
    public async Task Invoke(AspectContext context, AspectDelegate next)
    {
        context.AdditionalData.Add("CustomData", "CustomValue");
        await next(context);
    }
}

// 在被拦截的服务类中
public class MyService
{
    public void DoSomething()
    {
        // 使用 AspectContext.Current 获取当前上下文
        var context = AspectContext.Current;
        if (context?.AdditionalData.ContainsKey("CustomData") == true)
        {
            var data = context.AdditionalData["CustomData"];
        }
    }
}

方式 2：通过服务传递

如果 AspectContext.Current 不可用，可以通过构造函数注入或者方法参数传递：

public class MyService
{
    private readonly IServiceResolver _serviceResolver;
    
    public MyService(IServiceResolver serviceResolver)
    {
        _serviceResolver = serviceResolver;
    }
    
    public void DoSomething(object contextData)
    {
        // 使用传递的数据
    }
}

注意事项

• AspectContext.Current 是异步本地存储的值，在同一线程的异步调用链中可用
• 如果使用 Task.Run 等切换线程的方式，上下文会丢失
• 确保在正确的生命周期范围内访问