Using the Func as mentioned above works but there are also delegates that do the same task and also define intent within the naming:

public delegate double MyFunction(double x);

public double Diff(double x, MyFunction f)
{
    double h = 0.0000001;

    return (f(x + h) - f(x)) / h;
}

public double MyFunctionMethod(double x)
{
    // Can add more complicated logic here
    return x + 10;
}

public void Client()
{
    double result = Diff(1.234, x => x * 456.1234);
    double secondResult = Diff(2.345, MyFunctionMethod);
}

I think what you want is:

static object InvokeMethod(Delegate method, params object[] args){
    return method.DynamicInvoke(args);
}

static int Add(int a, int b){
    return a + b;
}

static void Test(){
    Console.WriteLine(InvokeMethod(new Func<int, int, int>(Add), 5, 4));
}

Prints "9".

It sounds like you want a Func<T>:

T GetCachedValue<T>(string key, Func<T> method) {
     T value;
     if(!cache.TryGetValue(key, out value)) {
         value = method();
         cache[key] = value;
     }
     return value;
}

The caller can then wrap this in many ways; for simple functions:

int i = GetCachedValue("Foo", GetNextValue);
...
int GetNextValue() {...}

or where arguments are involved, a closure:

var bar = ...
int i = GetCachedValue("Foo", () => GetNextValue(bar));

I am not sure what you are trying to achieve here. But to answer your question, you can pass methods as parameters using delegates. Here is an example:

public class ScriptA
{
    public delegate void MethodOneDelegate(int a, int b);

    public void MethodOne(int a, int b)
    {
        Console.WriteLine(a + b);
    }
}

public static class ScriptB
{
    public static void StaticMethod(ScriptA.MethodOneDelegate function, int a, int b)
    {
        function(a, b);
    }
}

public static void Main()
{
    ScriptA scriptA = new ScriptA();
    ScriptB.StaticMethod(scriptA.MethodOne, 1, 2);
}

There is alternative solutions, you can take a look at System.Func and System.Action.

Func<> Delegates are what you are looking for to pass methods in another method. I wrote a small example below, you can apply it according to your needs. Func<> is a generic delegate. It can be Func<int,string> Func<int,int,bool> and so on. The last one represents the return type and the others represent the input parameter types of method.

        static void Main(string[] args)
        {
            MethodB(MethodA);
            Console.ReadLine();
        }

        static string MethodA(string message) //Func<string,string>
        {
            return message;
        }

        static void MethodB(Func<string, string> method)
        {  
            Console.WriteLine(method("I am MethodA"));
        }

For more detailed information, you can check this link => https://www.tutorialsteacher.com/csharp/csharp-func-delegate