C# monkey patching / concrete members overriding

[przemo098]

Hello

I want to propose well known monkey patching
I think it wont be used often in app code, however it will simplify writing tests / overriding sealed classes in libs
What is really important in development lifecycle.
I know there are libraries like Harmony / Microsoft Fake / MockType, however all of them are commercial and cumbersome.
It's also possible with Castle Windsor / Mock libs however in case of overriding exisitng library / nuget it's impossible with concrete not virtual class members

Usage:

public class Calculator{
    public int Add(int a, int b){
        return a + b;
    }
}

Test.cs

var calc = new Calculator();
calc.Add = (int a, int b) => a * b;
calc.Add(4,4);  // return 16 instead 8

This effect can be achieved in different manors, maybe even introduction of new keyword like force would be enough

public class CalculatorProxy : Calculator{
    public **force** int Add(int a, int b){
        return a * b;
    }
}

Program.cs

Calculator calc = new CalculatorProxy();
calc.Add(4,4);   // expected 16 instead of 8

[HaloFour]

I don't even think that this would be possible from within the language itself. You'd effectively have to rewrite the target assembly, which is well outside of what the compiler can or should do.

[przemo098]

It's not for testing it's general approach what do you recommend than ?
Any team / repository in .NET area ?
also changing fundamentals will be usefull in case of destructuring

[przemo098]

@iam3yal
Calculator calc = new CalculatorProxy(); // not var
you can have

public void foo(Calculator calc){
    calc.Add();
}

[iam3yal]

@przemo098 Yes I noticed it later then I removed that part from my post. :)

[iam3yal]

@przemo098

It's not for testing it's general approach what do you recommend than ?

What do I recommend as opposed to monkey patching? or what do you mean?

You wrote the following in the OP:

I think it wont be used often in app code, however it will simplify writing tests / overriding sealed classes in libs

So dunno. 🤷‍♂️

[przemo098]

@iam3yal it will be for sure used more than generators

[FaustVX]

Can this be implemented with Source Generator & Interceptors ?

[HaloFour]

To a point? As soon as the target type is passed to another assembly outside of your control the interceptor would no longer be in play since the target type isn't actually changed in any way. At best it gives the illusion that the immediate callsite in the test is overridden, but you could just as easily have done that by calling an extension method or something else entirely.

[colejohnson66]

The solution here is dependency injection. Use interfaces.

[DavidArno]

Partially. Writing sociable unit tests helps too as it removes the need for over-zealous isolation, which is likely behind the OP's request for a way to mock things that don't need mocking.

[huoyaoyuan]

This will invalidate one of the most important optimizations - inlining. Knowing something to be invariant is important, including method bodies, initialized-once values.

[TonyValenti]

Take a look at libHarmony. We use the at for C# monkey patching and it works great.

[InCerryGit]

You can not only try Harmony, but also give Jitex a try; it should be able to solve some of your problems.
https://github.com/Hitmasu/Jitex