How can I change the behavior of a static method at runtime?

Question

Is there a way to modify the behavior of a static method at runtime?

for example:

Say I have this class

public class Utility {

    public static void DoSomething(string data){
        //...
    }
}

Is there a way to do something like this:

typeof(Utility).SetMethod("DoSomething", (data) => { /*Do something else...*/ });

Such that if you call Utility.DoSomething it executes the new code?

You could store the lambda in a variable maybe and have `DoSomething` invoke the variable? Then you can change that variable whenever you want to store a new lambda. But I'm not a C# dev... — Lightness Races in Orbit, Feb 24 '16 at 17:46
I've provided an answer, because it's pretty simple. But, I believe this question belongs on SO. — svidgen, Feb 24 '16 at 17:59
Not to be a pain, but isn't this question kind of off-topic since it's pretty much a how-to coding request? — Christine, Feb 24 '16 at 18:56
@Quezocotl: It's a "code is design" question. The kinds of questions we want to close here (aggressively) are the "fix my broken code" questions. — Robert Harvey, Feb 24 '16 at 22:32

score 10 · Accepted Answer · answered Feb 24 '16 at 17:59

10

What you want to do is pass the behavior you want as another parameter into the function.

public static void DoSomething(string data, Action<string> operation)
{
    operation(data);
}

This is an oversimplified example, of course. What you actually wind up doing in your own code is going to depend on what operation actually does.

If you're trying to modify the behavior of an existing, compiled, in-production method, and cannot overload or override the method in the usual ways, the only way I know of to do that is CIL Rewriting, possibly using an Aspect Weaver.

answered Feb 24 '16 at 17:59

Robert Harvey

178,213
47
333
501

But, if this is the solution, why not just call `operation` directly? – svidgen Feb 24 '16 at 18:00
It's a contrived example. For this particular scenario, that's exactly what I would do. But the OP said he wanted to change out the behavior of the method. – Robert Harvey Feb 24 '16 at 18:01
@RobertHarvey - I kinda made the assumption that he couldn't change the DoSomething method. Otherwise, he wouldn't be asking the question. – Christine Feb 24 '16 at 18:39
I would just create a new class that inherits from Utility. I don't like the idea of injecting code into a static method. – Christine Feb 24 '16 at 19:48

score 1 · Answer 2 · answered Feb 24 '16 at 17:58

1

Sure.

public class Utility {

    public static Action<String> _DoSomething;

    public static void DoSomething(string data){
        if (_DoSomething != null) {
            _DoSomething();
            return;
        }

        // default behavior here.
    }
}

And to mask the default behavior:

Utility._DoSomething = (data) => { /* do something else */ };

answered Feb 24 '16 at 17:58

svidgen

13,744
4
33
58

For what it's worth, you don't need a member variable to make this work, unless you're setting up some sort of "subscriber" scenario. – Robert Harvey Feb 24 '16 at 18:03
@RobertHarvey Not 100% sure what you mean. But, the member variable + method combination is there to avoid breakages when `_DoSomething = null` is called. ... Well ... unless it's *supposed* to break in that case! – svidgen Feb 24 '16 at 18:05

score -1 · Answer 3 · answered Feb 24 '16 at 18:01

I don't see why you wouldn't just create a new class that inherits from Utility and define a new function that does what you want.

public class Program
{
    static void Main(string[] args)
    {
        if (true)
        {
            Utility.DoSomething("TEST");
        } else
        {
            Util1.DoSomething("TEST");
        }
    }
}

public class Utility
{
    public static void DoSomething(string data)
    {
        //Perform some action
    }
}

abstract class Util1 : Utility
{
    public static new void DoSomething(string data)
    {
        //Perform a different action
    }
}

Also, isn't this question off-topic since the OP is asking us to debug code? Shouldn't this belong on SO? — Christine, Feb 24 '16 at 18:13

score -1 · Answer 4 · edited May 23 '17 at 10:28

I think although it is possible to do this you should ask yourself: "Why do I need this functionality"? Usually a method stays as is, and does what it is supposed to do according to its interface which is given by its name and signature. So while you can add additional logic by adding an Action<T>-parameter to your signature you should ask yourself if this won´t break the contract of the interface and therefor what the method was designed for.

Having said this you should consider either overwrite your method if the functionality you need is some kind of "making the same things differently then the parent-class" or extend it by adding a dependency into your consuming class and add some methods to that class that extent the functionality provided by the contained class (see also favour composition over inheritance)

class MyClass {
    Utility MyUtility;

    void ExtraMethod() { /* ... */ }
}

EDIT: As you´re using a static method the opportunity on overwriting is obsolete. However IMO that sounds like a great design-flaw.

How can I change the behavior of a static method at runtime?

4 Answers4