好的，这可能会很长。我正在尝试做两件事:

• 我想要一个类，该类通过保存每个调用都路由到的另一个类的实例来实现接口(interface)。

• 我也想拦截所有的方法调用，做点什么。

单独完成这两件事效果很好。将它们组合起来似乎只在一个执行顺序中有效，正如 Murphy 所说，这是错误的顺序(至少对我而言)。

我想先注入(inject)组合，这样所有调用的拦截也将拦截之前注入(inject)的那些。

namespace ConsoleApplication13
{
  using System;
  using System.Reflection;

  using PostSharp;
  using PostSharp.Aspects;
  using PostSharp.Aspects.Dependencies;
  using PostSharp.Extensibility;

  [Serializable]
  [ProvideAspectRole("COMPOSER")]
  public sealed class ComposeAspectAttribute : CompositionAspect
  {
    [NonSerialized]
    private readonly Type interfaceType;

    private readonly Type implementationType;

    public ComposeAspectAttribute(Type interfaceType, Type implementationType)
    {
      this.interfaceType = interfaceType;
      this.implementationType = implementationType;
    }

    // Invoked at build time. We return the interface we want to implement. 
    protected override Type[] GetPublicInterfaces(Type targetType)
    {
      return new[] { this.interfaceType };
    }

    // Invoked at run time. 
    public override object CreateImplementationObject(AdviceArgs args)
    {
      return Activator.CreateInstance(this.implementationType);
    }
  }

  [Serializable]
  [ProvideAspectRole("INTERCEPTOR")]
  [MulticastAttributeUsage(MulticastTargets.Method)]
  [AspectRoleDependency(AspectDependencyAction.Order, AspectDependencyPosition.After, "COMPOSER")]
  public sealed class InterceptAspectAttribute : MethodInterceptionAspect
  {
    public override void CompileTimeInitialize(MethodBase method, AspectInfo aspectInfo)
    {
      base.CompileTimeInitialize(method, aspectInfo);

      // Warning in VS output
      Message.Write(method, SeverityType.Warning, "XXX", "Method: " + method.Name);
    }

    public override void OnInvoke(MethodInterceptionArgs args)
    {
      Console.WriteLine("Intercepted before");
      args.Proceed();
      Console.WriteLine("Intercepted after");
    }
  }

  interface ITest
  {
    void Call();
  }

  class TestImpl : ITest
  {
    public void Call()
    {
      Console.WriteLine("CALL remote implemented");
    }
  }

  [InterceptAspect(AspectPriority = 1)]
  [ComposeAspect(typeof(ITest), typeof(TestImpl), AspectPriority = 2)]
  class Test
  {
    // this should, after compilation, have all methods of ITest, implemented through an instance of TestImpl, which get intercepted before TestImpl is called

    public void CallLocalImplementedTest()
    {
      Console.WriteLine("CALL local implemented");
    }
  }


  class Program
  {
    static void Main()
    {
      var test = new Test();

      ITest t = Post.Cast<Test, ITest>(test);

      Console.WriteLine("TEST #1");
      t.Call();

      Console.WriteLine("TEST #2");
      test.CallLocalImplementedTest();

      Console.ReadLine();
    }
  }
}

我试图通过以下方式影响这两个方面的执行顺序

• AspectRoleDependency，让拦截器先依赖composer运行

• AspectPriority，也让 composer 先运行。

因为测试总有结果

TEST #1
CALL remote implemented

TEST #2
Intercepted before
CALL local implemented
Intercepted after

显然不行。你知道为什么我的执行顺序没有改变吗？我做错了什么，我错过了文档中的细节吗？我还能做些什么来拦截我的组合注入(inject)方法？

最佳答案

使用当前的方面和您当前的设置，您无法达到您想要的结果。

问题在于 Postsharp 的工作方式:它一步完成 IL waving，它只将 InterceptAspect 应用于在原始编译时存在的方法，所以它没有看到使用 ComposeAspect 添加的新接口(interface)实现。

因此，接受或提供角色、优先级或其他配置的排序在这里都无济于事。

一种解决方法是在注入(inject)的 TestImpl 类上添加 InterceptAspect:

[InterceptAspect]
class TestImpl : ITest
  {
    public void Call()
    {
      Console.WriteLine("CALL remote implemented");
    }
  }

在这种情况下，日志记录逻辑将直接添加到 TestImpl 中，因此这些方法将包含日志记录，当它被组合到您的 Test 类中时。

或者，如果您不标记每个实现，您可以将方面放在界面本身上:

[InterceptAspect(AttributeInheritance = MulticastInheritance.Multicast)]
interface ITest
{
   void Call();
}

关于c# - Postsharp Aspects 执行顺序，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/24330484/