Error CS0121 with double and int

Question

I have an error:

Error CS0121 The call is ambiguous between the following methods or properties: 'Program.calculateFee(double, int)' and 'Program.calculateFee(double)' DailyRate.

here is my code:

     void run()
        {
            double fee = calculateFee();
            Console.WriteLine("Fee is {0}", fee);
        }

        private double calculateFee(double theDailyRate = 500.0, int no0fdays = 1)
        {
            Console.WriteLine("calculateFee using two optional parameters");
            return theDailyRate * no0fdays;
        }

        private double calculateFee(double dailyRate = 500.0)
        {
            Console.WriteLine("calculateFee using one optional parameter");
            int defaultNo0fDays = 1;
            return dailyRate * defaultNo0fDays;
        }

        private double calulateFee()
        {
            Console.WriteLine("calculateFee using hardcoded values");
            double defaultDailyRate = 400.0;
            int defaultNo0fDays = 1;
            return defaultNo0fDays * defaultDailyRate;
        }
    }
}

edit: why does this one do work??

 static void Main(string[] args)
    {
        (new Program()).run();
    }

    void run()
    {
        double fee = calculateFee();
        Console.WriteLine("Fee is {0}", fee);
    }

    private double calculateFee(double theDailyRate = 500.0, int noOfDays = 1) 
    {
        Console.WriteLine("calculateFee using two optional parameters"); 
        return theDailyRate * noOfDays; 
    }

    private double calculateFee(double dailyRate = 500.0) 
    {
        Console.WriteLine("calculateFee using one optional parameter"); 
        int defaultNoOfDays = 1; 
        return dailyRate * defaultNoOfDays; 
    }

    private double calculateFee() 
    {
        Console.WriteLine("calculateFee using hardcoded values"); 
        double defaultDailyRate = 400.0; 
        int defaultNoOfDays = 1; 
        return defaultDailyRate * defaultNoOfDays; 
    }

Since you are using default parameters for both overloads and one with no parameters, the compiler can't figure out which one you want to call when you write `calculateFee()`. If you read it, how would you figure out which one should be called when default parameters are used? The reason its not complaining about the last one is because its misspelled. — Ron Beyer, Jul 28 '15 at 14:45
And you should always use `decimal`instead of `double` when you're working with money. — MikeSW, Jul 28 '15 at 14:46
`private double calculateFee(double theDailyRate = 500.0, int no0fdays = 1)` makes the other two kinda pointless since it already encompasses all 3 use cases. — Powerlord, Jul 28 '15 at 14:47
does your second example actually work? Or does it just build? There is a pretty big difference — pquest, Jul 28 '15 at 14:53

D Stanley · Accepted Answer · 2015-07-28T15:06:14.377

EDIT

The second example works because you have fixed the misspelling of calulateFee(), allowing the compiler to bind to the method that exactly matches the call (no parameters).

When calculateFee was misspelled, the compiler did not find a method that exactly matched the name and parameters, so it began searching for appropriate overloads. It find two - one with one optional parameter and one with two. The overload resolution rules do not allow the compiler to pick one method over the other, so it results in a build error.

From MSDN:

If more than one candidate is found, overload resolution rules for preferred conversions are applied to the arguments that are explicitly specified. Omitted arguments for optional parameters are ignored.

If two candidates are judged to be equally good, preference goes to a candidate that does not have optional parameters for which arguments were omitted in the call. This is a consequence of a general preference in overload resolution for candidates that have fewer parameters.

Since the last method exactly matches your calling signature, it is chosen. When it was misspelled, two other "equally good" candidates were found. Since optional parameters are ignored, there are no rules to dictate that one overload be chosen over another.

ORIGINAL ANSWER

You have one method with an optional double parameter and another method with an optional double parameter and an optional int parameter. When you call it with no parameters the compiler doesn't know if you want to call the method with no parameters, with just the double parameter or with the double and int parameters. You have some options to fix this:

Either use optional parameters or use overloads; there's no reason to use both.

score 1 · Answer 2 · answered Jul 28 '15 at 14:56

The reason is that in run() you call calculateFee().

Since both methods only have optional parameters it doesn't know which one you are trying to call (hence the ambiguous). Without any parameters any of the methods without declared without parameters or only optional parameters can be called.

Optional parameters means that they can be included in the call or not. These methods should be combined to the top one calculateFee(double theDailyRate = 500.0, int noOfDays = 1).

    private double calculateFee(double theDailyRate = 500.0, int no0fdays = 1){
        ...
    }

    private double calculateFee(double dailyRate = 500.0)
    {
        ...
    }

Error CS0121 with double and int

2 Answers2