Monkey Patching in C#

Question

Is it possible to extend or modify the code of a C# class at runtime?

My question specifically revolves around Monkey Patching / Duck Punching or Meta Object Programming (MOP), as it happens in scripting languages such as Groovy, Ruby etc.

Lochner

You could however go by the IronRuby (or siblings) route to get dynamic features in C# – Anarchic

I know this question is ancient. But there really should be a link to Microsoft Fakes, as I assume part of the reason people monkey patch in these languages is testing. Moqs are also worth a look. – Limemann

You can do it with some AOP Framework. I am working actively on one of them here : NConcern .NET runtime AOP Framework You can check a sample in this post : monkey patch sample – Fenestra

Answer 1

Is it possible to extend or modify the code of a C# class at run-time?

No it is not possible to do this in .NET. You could write derived classes and override methods (if they are virtual) but you cannot modify an existing class. Just imagine if what you were asking was possible: you could modify the behavior of some existing system classes like System.String.

You may also take a look at Extension methods to add functionality to an existing class.

Grievous

I guess that is the just the kind of thing humblecoder is looking for. e.g. Adding a method to the String type to parse a custom type from a string representation so that you could do var serialObject = "STB-2".ToMySerial() – Anarchic

@Gishu, yes, we could use extension methods to add methods to existing classes but we cannot modify existing methods. – Grievous

. right. Extension methods can work for some needs.. however opening up a class as in Ruby is still not possible as you have answered - which is what the OP seems to be after. – Anarchic

I want to add methods dynamically as it's being done in Grails/Ruby Active Record. – Lochner

AFAIK it is possible to change methods of some classes at runtime or even you can change classes at runtime, but it needs deep knowledge of clr and changing memory structures at runtime. – Cordless

"Just imagine what would happen"--not need to imagine. Python allows this, and while it's always a backdoor and nobody's ever really happy when it becomes necessary, it's an extremely powerful tool for working around real-world problems. The idea that something shouldn't be allowed because there's a possibility of it being misused is no way to design a language. – Mechellemechlin

Monkey patching allows you to mock services like cloud apps and resources that would then allow you to run meaningful unit tests against your code without having to add special cases to your production code. And, that's just one example of how monkey patching is powerful and a good thing to have. See the moto Python package that mocks a great deal of AWS services so you can test your shippable code without polluting it with unit testing contraptions and kludges. – Simonides

@GlennMaynard It's exactly how you design a language if you expect it to be used for long-lived code maintained by dozens of different people who won't know about all the quirks introduced by monkeypatching – Onida

Answer 2

For those still stumbling on this question in the present day, there is indeed a present-day library called Harmony that relatively-straightforwardly enables such monkey-patching at runtime. Its focus is on video game modding (particularly games built with Unity), but there ain't much stopping folks from using it outside of that use case.

Copying the example from their introduction, if you have an existing class like so:

public class SomeGameClass
{
    public bool isRunning;
    public int counter;

    private int DoSomething()
    {
        if (isRunning)
        {
            counter++;
        }
        return counter * 10;
    }
}

Then Harmony can patch it like so:

using HarmonyLib;
using Intro_SomeGame;

public class MyPatcher
{
    // make sure DoPatching() is called at start either by
    // the mod loader or by your injector

    public static void DoPatching()
    {
        var harmony = new Harmony("com.example.patch");
        harmony.PatchAll();
    }
}

[HarmonyPatch(typeof(SomeGameClass))]
[HarmonyPatch("DoSomething")]
class Patch01
{
    static AccessTools.FieldRef<SomeGameClass, bool> isRunningRef =
        AccessTools.FieldRefAccess<SomeGameClass, bool>("isRunning");

    static bool Prefix(SomeGameClass __instance, ref int ___counter)
    {
        isRunningRef(__instance) = true;
        if (___counter > 100)
            return false;
        ___counter = 0;
        return true;
    }

    static void Postfix(ref int __result)
    {
        __result *= 2;
    }
}

Here, we have a "prefix" patch which gets inserted before the original method runs, allowing us to set variables within the method, set fields on the method's class, or even skip the original method entirely. We also have a "postfix" patch which gets inserted after the original method runs, and can manipulate things like the return value.

Obviously this ain't quite as nice as the sorts of monkey-patching you can do in e.g. Ruby, and there are a lot of caveats that might hinder its usefulness depending on your use case, but in those situations where you really do need to alter methods, Harmony's a pretty proven approach to doing so.

Winterwinterbottom

Answer 3

You can add functionality, but you cannot change or remove functionality.

Indication

How it's possible? An illustration is appreciated? – Lochner

Extension methods allow you to add methods to objects (that's how the function-side of LINQ is implemented). The link plaes provided contains all the info you should need. – Indication

Extension methods only allow an opportunity to add functionality at compile time, not at runtime. If you're going to add functionality at runtime, you need to be working with an object that derives from DynamicObject – Doggo

Good catch. Somehow I stepped right over that "run time" part. – Indication

Answer 4

You can extend classes by adding extra methods, but you cannot override them because added methods have always lower priority than existing ones.

For more info, check Extension Methods in C# Programming Guide.

Smoko