Aggiunta di codice all'inizio/fine dei metodi in runtime dinamicamente

Question

So che la strumentazione è una tecnica per aggiungere dinamicamente il codice di traccia nei metodi per abilitare la traccia e il debug.

Mi chiedevo se questa è solo un'opzione "Traccia", codificata nel CLR per aggiungere solo il codice di traccia, oppure esiste la possibilità di aggiungere qualsiasi codice ai metodi?

Ad esempio, desidero verificare una condizione all'inizio di ogni singola chiamata di metodo in una determinata classe (ad esempio per le autorizzazioni). Posso farlo aggiungendo codice dinamico all'inizio dei metodi in tempo di esecuzione?

Non sono sicuro di come funzioni questa "strumentazione" di traccia, ma mi chiedo se questo può essere utilizzato anche per altri obiettivi o no.

Answer 1

In sostanza ciò che si dovrebbe fare è scrivere un profiler CLR e utilizzare il profiler API in C++
È necessario implementare l'interfaccia ICorProfilerCallback.
Quello che stai cercando è nel callback JITCompilationStarted. Questo metodo viene chiamato ogni volta che viene richiamato un metodo gestito e prima che il compilatore jit compili l'IL in codice macchina. Qualsiasi operazione di inserimento del codice durante il periodo di esecuzione deve essere eseguita in JITCompilationStarted.
Puoi guardare lo strumento di copertura open source part cover come esempio su come farlo.

Answer 2

So PostSharp consente di aggiungere 'aspetti' ai metodi già esistenti, mediante l'attribuzione in modo da poter aggiungere entrata/uscita tracce sui vostri metodi

Answer 3

Si riferisce alla Aspect Oriented Programming (AOP).

Dai un'occhiata allo PostSharp.

anche: Open Source Aspect-Oriented Frameworks in C#

Answer 4

Come altri hanno risposto, come ad trasversale preoccupazioni sono spesso affrontate con Aspect Oriented Programming (AOP).

Un modo per farlo è AOP con strumentazione codice con strumenti come PostSharp, ma un'alternativa che non richiede attrezzi aggiuntivi è utilizzando Dependency Injection (DI) e il modello Decorator design.

Immaginate che il codice consuma l'interfaccia IFoo:

public interface IFoo 
{ 
    string GetStuff(string request); 
} 

Si può avere un implmentation concreta MyFoo di IFoo, ma si può anche scrivere uno o più decoratori che gestiscono i diversi aspetti:

public class AdministratorGuardingFoo : IFoo 
{ 
    private readonly IFoo foo; 

    public AdministratorGuardingFoo(IFoo foo) 
    { 
     if (foo == null) 
     { 
      throw new ArgumentNullException("foo"); 
     } 

     this.foo = foo; 
    } 

    public string GetStuff(string request) 
    { 
     new PrincipalPermission(null, "Administrator").Demand(); 

     return this.foo.GetStuff(request);    
    } 
} 

È ora possibile (disporre del contenitore DI) avvolgere MyFoo in AdministratorGuardingFoo. Tutti i consumatori che consumano IFoo non noteranno la differenza.

Answer 5

Il CLR consente l'intercettazione del metodo tramite sink di messaggi.

• http://twelvestone.com/forum_thread/view/19568
• http://blogs.msdn.com/abhinaba/archive/2006/01/23/516163.aspx