Cómo inyectar código C# en tiempo de compilación?

Question

Me gustaría poder decorar cualquier método con un atributo Trace personalizado y algún fragmento de código debe ser inyectado en ese método en la compilación.

Por ejemplo:

[Trace] 
public void TracedMethod(string param1) 
{ 
    //method body 
} 

debe convertirse en:

public void TracedMethod(string param1) 
{ 
    Log.Trace("TracedMethod", "param1", param1); 
    //method body 
} 

En este caso, el código inyectado depende de los parámetros nombre del método y del método, lo que debe ser posible deducir esta información.

¿Alguien sabe cómo lograr esto?

Answer 1

Para hacer la Programación Orientada a Aspectos en C#, puede usar PostSharp.

(The homepage incluso muestra un ejemplo Trace, al igual que lo está pidiendo!)

Answer 2

Esto puede hacerse fácilmente con un sistema de transformación de programas.

DMS Software Reengineering Toolkit es un sistema de transformación de programa de propósito general, y se puede usar con muchos lenguajes (C++, COBOL, Java, EcmaScript, Fortran, ..) así como específicamente con C#.

DMS analiza el código fuente, crea árboles de sintaxis abstracta y le permite aplicar patrones de fuente a fuente para transformar su código de un programa C# a otro con las propiedades que desee. La regla de transformación para llevar a cabo exactamente la tarea que ha especificado sería:

domain CSharp. 

insert_trace():method->method 
    "[Trace] 
    \visibility \returntype \methodname(string \parametername) 
    { \body } " 
     -> 
    "\visibility \returntype \methodname(string \parametername) 
    { Log.Trace(\CSharpString\(\methodname\), 
       \CSharpString\(\parametername\), 
       \parametername); 
     \body } " 

Las comillas (") no son comillas CSharp, sino que son 'citas de dominio', e indican que el contenido dentro de las comillas es la sintaxis CSharp (ya dijimos, "dominio CSharp"). las notaciones \ foo son sintaxis meta.

Esta regla coincide con la AST que representa el método que ha especificado con la [traza] anotación, y reescribe que AST en la forma rastreada. Luego, la AST resultante se vuelve a imprimir en forma de fuente, que puede compilar. Probablemente necesite otras reglas para manejar otras combinaciones de argumentos; actuar, probablemente generalizaría el procesamiento del argumento para producir (cuando sea práctico) un valor de cadena para cada argumento escalar.

Debe quedar claro que puede hacer mucho más que simplemente iniciar sesión con esto, y mucho más que solo la programación orientada a aspectos, ya que puede expresar transformaciones arbitrarias y no solo acciones previas y posteriores.