Replacing a .NET type at runtime

Question

I have a .NET assembly which has defined a type T at compile time, and I have instantiated an object my_t as an instance of this type.

I am wondering if it is possible in .NET to use the runtime compiler services to re-compile this class, then load the new class definition into the currently executing assembly, so when I call methods off of my_t, they will use the new code.

I am not changing the signatures of any of the methods, just the method bodies.

Any .NET gurus out there know if this is possible? Thanks in advance for any help!

Answer 1

A .NET object can't change type at runtime; it's a fundamental assumption in the CLR.

A few suggestions:

1. Write the code for T to forward calls to the right type as appropriate. It can forward to a type that gets compiled at runtime if you want to.
2. Use some kind of aspect-orientated or dynamic proxy framework to automate (1) for you
3. If this kind of forwarding isn't suitable, I believe there is a .NET profiling API available to native that lets you intercept the JIT process. All I know of this is that tools like NCover are able to inject their own machine code this way.

Answer 2

To expand upon my comment:

public class Base
{
    public virtual void Method()
    {

    }
}

public class Sub : Base
{
    public override void Method()
    {

    }
}

public void DoStuff<T>() where T : Base, new()
{
    var instance = new T();
    instance.Method();
}

Answer 3

I'm not sure that is possible, but if it is, it sounds like an awfully messy solution.

Use a plugin architecture, so you can dynamically compile your generated plugin, inheriting from your plugin interface and simply load that type from your newly created assembly and inject it into your plugin container.

Answer 4

you can use castle dynamic proxy to create a proxy of your class. The proxy is a new type that would let you inject new implementation, but anything that you want to inject would have to declared as virtual.