一种方法的多个方面

Question

在我的应用程序中，我之前使用常规 C# 属性来“注释”方法。例如：

[Foo(SomeKey="A", SomeValue="3")]
[Foo(SomeKey="B", SomeValue="4")]
public void TheMethod()
{
   SpecialAttributeLogicHere();
}

SpecialAttributeLogicHere() 所做的是反思性地查看注释此特定方法的所有 Foo 属性。然后，它会（自行）为所有键和值创建自己的字典。

我现在尝试转向 PostSharp，因为 SpecialAttributeLogic 可以放入 OnEntry 中的一个方面（并从方法体中删除，这更干净！）。 Foo 将被扩展 OnMethodBoundaryAspect 的方面所取代。

我仍然想按以下方式使用它：

[Foo(SomeKey="A", SomeValue="3")]
[Foo(SomeKey="B", SomeValue="4")]

但是如果 Foo 有一个 OnEntry，这意味着“SpecialAttributeLogic”将被执行两次。我基本上需要将每个 Foo() 中的所有键和值“收集”到一个字典中，然后应用一些逻辑。

如何使用 PostSharp 做到这一点（或最佳实践）？谢谢！

Answer 1

看起来您想在方法内部构建一个名称值对。你不能用一个方面来做到这一点。我建议您使用 MethodInterceptionAspect 并反映方法上的属性，然后构建集合并通过参数（可能使用重载方法）将其传递到方法中或将其设置为类成员。

您可以在编译时反映这些值，以保持最佳性能。

这是解决您问题的快速方法。它有点难看（您需要进行修改才能适应）。还有其他方法，但它们并不那么“通用”。

namespace ConsoleApplication12
{
    class Program
    {
        static void Main(string[] args)
        {
            MyExampleClass ec = new MyExampleClass();
            ec.MyMethod();
        }
    }

    public class MyExampleClass
    {
        [Special(Key = "test1", Value = "1234")]
        [Special(Key = "test2", Value = "4567")]
        [MyAspect]
        public void MyMethod()
        {
            MyMethod(new Dictionary<string, string>());
        }

        public void MyMethod(Dictionary<string, string> values)
        {
            //Do work
        }

    }

    [Serializable]
    public class MyAspect : MethodInterceptionAspect
    {
        Dictionary<string, string> values = new Dictionary<string, string>();
        MethodInfo target;

        public override void CompileTimeInitialize(System.Reflection.MethodBase method, AspectInfo aspectInfo)
        {
            target = method.DeclaringType.GetMethod(method.Name, new Type[] { typeof(Dictionary<string, string>) });

            foreach (Attribute a in method.GetCustomAttributes(false))
            {
                if (a is SpecialAttribute)
                {
                    values.Add(((SpecialAttribute)a).Key, ((SpecialAttribute)a).Value);
                }
            }
        }

        public override void OnInvoke(MethodInterceptionArgs args)
        {
            if (values == null || values.Count < 1)
            {
                args.Proceed();
            }
            else
            {
                target.Invoke(args.Instance, new object[] { values });
            }

        }
    }
    [AttributeUsage(AttributeTargets.Method, AllowMultiple = true) ]
    public class SpecialAttribute : Attribute
    {
        public string Key { get; set; }
        public string Value { get; set; }
    }
}

目标和值都在编译时（而不是运行时）初始化，以便在运行时使用。它们在编译时通过方面进行序列化。这样您就可以节省运行时的反射命中。

Answer 2

需要注意的是，我最终使用了 MethodInterceptionAspect 并且只重写了 OnInvoke。在 OnInvoke 中，我查看了 args.Method.GetCustomAttributes()，给出了我设置的所有 System.Attributes（即 DustinDavis 示例中的 SpecialAttribute）。

使用这些属性及其属性，我可以运行我需要运行的逻辑。如果逻辑成功，我会以 args.Proceed() 结束，如果没有，我会抛出异常。