如何将管道代码注入/生成到用属性装饰的方法中？

Question

我正在阅读一些有关缓存和记忆化以及如何使用委托和泛型轻松实现它的文章。语法非常简单，并且非常容易实现，但我只是觉得由于重复性，应该可以基于属性生成代码，而不必一遍又一遍地编写相同的管道代码。

假设我们从默认示例开始：

class Foo
{
  public int Fibonacci(int n)
  {
    return n > 1 ? Fibonacci(n-1) + Fibonacci(n-2) : n;
  }
}

然后记住这一点：

// Let's say we have a utility class somewhere with the following extension method:
// public static Func<TResult> Memoize<TResult>(this Func<TResult> f)

class Foo
{
  public Func<int,int> Fibonacci = fib;

  public Foo()
  {
    Fibonacci = Fibonacci.Memoize();
  }

  public int fib(int n)
  {
    return n > 1 ? Fibonacci(n-1) + Fibonacci(n-2) : n;
  }
}

我想，一旦找到与 Memoize 扩展之一匹配的标记方法，制作一个代码生成器来吐出此代码不是更简单吗方法。因此，我可以不编写此管道代码，而只需添加一个属性：

class Foo
{
  [Memoize]
  public int Fibonacci(int n)
  {
    return n > 1 ? Fibonacci(n-1) + Fibonacci(n-2) : n;
  }
}

老实说，我知道这看起来更像是应该由预处理器转换的编译器糖，而不是实际的代码生成，但我的问题是：

1. 您认为最好的是什么如何在 ac# 源文件中查找具有给定属性的方法，解析参数类型和返回类型，并生成与此指纹匹配的委托
2. 将其集成到构建过程中的最佳方法是什么，而不实际覆盖我的代码。在将源文件传递给编译器之前是否可以对其进行一些预处理？

感谢您的任何和所有想法。

更新：

我按照 Shay 的建议研究了 Postsharp 库，它似乎非常适合非时间关键型应用程序（如事务管理、跟踪或安全）的工作。

然而，当在时间紧迫的环境中使用它时，它比委托慢很多。每次实现斐波那契示例的一百万次迭代都会导致运行时间减慢 80 倍。 （0.012ms postsharp vs 0.00015ms delegate per call）

但老实说，在我打算使用它的上下文中，结果是完全可以接受的。感谢您的回复！

更新2：

显然Postsharp的作者正在努力开发release 2.0 其中将包括生成代码的性能改进和编译时间。

Answer 1

我遇到这个使用postsharp的memoizer属性

Answer 2

我在我的项目中使用了以下 Memoize 函数：

public class Foo
{
    public int Fibonacci(int n)
    {
        return n > 1 ? Fibonacci(n - 1) + Fibonacci(n - 2) : n;
    }
}

class Program
{
    public static Func<Т, TResult> Memoize<Т, TResult>(Func<Т, TResult> f) where Т : IEquatable<Т>
    {
        Dictionary<Т, TResult> map = new Dictionary<Т, TResult>();
        return a =>
        {
            TResult local;
            if (!TryGetValue<Т, TResult>(map, a, out local))
            {
                local = f(a);
                map.Add(a, local);
            }
            return local;
        };
    }

    private static bool TryGetValue<Т, TResult>(Dictionary<Т, TResult> map, Т key, out TResult value) where Т : IEquatable<Т>
    {
        EqualityComparer<Т> comparer = EqualityComparer<Т>.Default;
        foreach (KeyValuePair<Т, TResult> pair in map)
        {
            if (comparer.Equals(pair.Key, key))
            {
                value = pair.Value;
                return true;
            }
        }
        value = default(TResult);
        return false;
    }


    static void Main(string[] args)
    {
        var foo = new Foo();
        // Transform the original function and render it with memory
        var memoizedFibonacci = Memoize<int, int>(foo.Fibonacci);

        // memoizedFibonacci is a transformation of the original function that can be used from now on:
        // Note that only the first call will hit the original function
        Console.WriteLine(memoizedFibonacci(3));
        Console.WriteLine(memoizedFibonacci(3));
        Console.WriteLine(memoizedFibonacci(3));
        Console.WriteLine(memoizedFibonacci(3));
    }
}

在我的项目中，我只需要带有单个参数的函数来实现 IEquatable<Т> 但这可以进一步概括。
另一个重要的说明是这段代码不是线程安全的。如果需要线程安全，则需要同步对内部映射哈希表的读/写访问。

Answer 3

具体阐述您的观点：

1. 这可能很难做到
   按照你描述的方式，如
   你需要一个成熟的 C# 语法
   解析器。什么可能是更可行的
   另一种方法是编写托管应用程序
   可以加载编译后的
   组装和提取类型
   使用反射的信息。这
   将涉及获取所有类型
   给定组件中的对象，寻找
   对于类型的方法，检索
   自定义属性，然后
   发出记忆代码（这个
   部分可能有点困难）。
2. 如果你走我在#1中提到的路线，你可以简单地
   添加构建后步骤来运行您的工具。视觉工作室
   （它在下面使用 MSBuild）使这相对容易。

Answer 4

如果您为 PostSharp 编写插件而不是使用其 LAOS 库，则不会受到性能影响。