Overload Method Cost in .Net

Question

Are there any costs associated with overloading methods in .Net?

So, if I have 3 methods like:

Calculate (int)
Calculate (float)
Calculate (double)

and these methods are called "dynamically" at runtime based on what is passed to the Calculate method, what will the cost of this overload resolution be?

Alternatively, I could have one Calculate and make changes to the body of the method, but I thought it would require the method to evaluate the type every time it called.

Are there any better ways / projects to solve this, maybe not overhead? Or better yet, which is best suited for such cases? I want to have the same class / method name, but different behavior.

EDIT: Thanks to everyone. Jusdt is one thing if it is another. I was wondering if you have a DLL for these methods and a program written in C # that allows the user to add these methods as user interface elements (without specifying a type). So the user adds the UI element Calculate (5) and then Calculate (12.5), etc., And the C # application does this, will there be overhead?

Answer 1

Regarding runtime, these are various methods . Same as entry:

CalculateInt(int)
CalculateFloat(float)

, , .

Answer 2

, . , , , , .

, .

Answer 3

-, , .

, . , . , .

Answer 4

(.. ) , , .

, virtual, , . , .

Answer 5

"", , . , , , .

, ,

public class Calculator
{
    public void Calculate(int value)
    {
        //Do Something
    }
    public void Calculate(decimal value)
    {
        //Do Something
    }
    public void Calculate(double value)
    {
        //Do Something
    }
}

static void Main(string[] args)
{
    int i = 0;
    Calculator calculator = new Calculator();
    calculator.Calculate(i);
}

IL "i":

L_000b: callvirt instance void ConsoleApplication1.Calculator::Calculate(int32)

, , int32, , , Main.

, , . .

JaredPar, :

. # . . , "" , .

Answer 6

IL 3 . , , , . , Calculate (double) .

Answer 7

. # . . , "" , , .

Note. This changes a bit with C # 4.0 and dynamic. With a dynamic object, it is possible that an overload will be selected at runtime depending on the type of object. This does not apply to C # 3.0 and below.