Adding code to the beginning / end of methods in runtime dynamically

StackOverflow https://stackoverflow.com/questions/2461862

Question

I know instrumentation is a technique to add trace code dynamically into the methods to enable tracing and debugging.

I was wondering if this is only a "Trace" option, hard coded into the CLR to add only trace code, or is there the ability to add any code to the methods?

For example, I want to check for a condition in the beginning of every single method call in a certain class (say for permissions). Can I do this via adding dynamic code to the beginning of the methods in execution time?

I'm not sure how this trace "instrumentation" thing works, but I'm wondering if this can be used for other goals too, or not.

Was it helpful?

Solution

Basically what you should do is write a CLR profiler and use the profiler API in c++
You need to implement the ICorProfilerCallback interface.
What you are looking for is in the JITCompilationStarted callback. This method is called each time a managed method gets called and before the jit compiler compiles the IL into machine code. Any code insertion work during run time should be done in JITCompilationStarted.
You can look at the open source coverage tool part cover as an example how to do it.

OTHER TIPS

You are referring to Aspect Oriented Programming (AOP).

Have a look at PostSharp.

Also: Open Source Aspect-Oriented Frameworks in C#

As others have answered, such Cross-Cutting Concerns are often addressed with Aspect Oriented Programming (AOP).

One way to do AOP is with code instrumentation with tools such as PostSharp, but an alternative that requires no extra tools is by utilizing Dependency Injection (DI) and the Decorator design pattern.

Imagine that your code consumes the IFoo interface:

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

You may have a concrete implmentation MyFoo of IFoo, but you can also write one or several Decorators that handle different aspects:

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);            
    }
}

You can now (have your DI Container) wrap MyFoo in AdministratorGuardingFoo. All consumers that consume IFoo will not notice the difference.

I know PostSharp allows you to add 'aspects' to existing methods via attributing so you can add entry/exit traces onto your methods

Licensed under: CC-BY-SA with attribution
Not affiliated with StackOverflow
scroll top