static class FuncProvider {
    public Func<int, int, int> Sum = (a,b) => a+b; // delegate or pointer to function
}

class SomeObject {
    public void Method(int a, int b)
    {
        var r = FuncProvider.Sum(a, b);
    }
}

// standard code 
var obj = new SomeObject();
obj.Method(1,2);

// code with overriden Sum function
FuncProvider.Sum = (a,b) => {
    if (/*some condition*/) return a+b;
    return 0;
};
var obj = new SomeObject();
obj.Method(1,2);

class SomeObject
{
  private const Func<int, int, int> Sum;
  public SomeObject(Func<int, int, int> f) {this.Sum=f;}
}
// standard code 
var obj = new SomeObject(FuncProvider.Sum);
obj.Method(1,2);

// или так, если SomeObject иммутабелен
static class SomeObjectDefaults
{
   public const SomeObject DEFAULT = new SomeObject((a, b) => a+b);
}
...
var obj = SomeObjectDefaults.DEFAULT;
obj.Method(1,2);


// code with overriden Sum function
var obj = new SomeObject((a,b) => {
        if (/*some condition*/) return a+b;
        return 0;
    });
obj.Method(1,2);

...
// standard code 
Provider<SomeObject> someObjectProvider = () => new SomeObject((a, b) => a+b);
...
SomeObject obj = someObjectProvider.get();
obj.Method(1,2);

// code with overriden Sum function
Provider<SomeObject> someObjectProvider = () => new SomeObject((a, b) {
        if (/*some condition*/) return a+b;
        return 0;
    });
...
SomeObject obj = someObjectProvider.get();
obj.Method(1,2);

_> и категоризм про статик-переменные тоже не понял

_>

class SomeObject 
{
    private FuncProvider _provider;

    public SomeObject (FuncProvider provider) 
    {
        _provider = provider;
    }
    public void Method(int a, int b)
    {
        var r = _provider.Sum(a, b);
    }
}

class SomeObject 
{
    virtual public void Sum(int a, int b) 
    {
       ...
    }

    public void Method(int a, int b)
    {
        var r = _provider.Sum(a, b);
    }
}

class SomeDerived : SomeObject 
{
    override virtual public void Sum(int a, int b) 
    {
       ...
    }
}