C＃：使用可选参数和命名参数覆盖方法：意外结果

Question

I have two classes FirstProcess and Second Process

public class FirstProcess
    {
        public virtual void Calculate(int x, int y)
        {
            Console.WriteLine("First Process  X :{0} and Y{1}", x, y);
        }
    }
    public class SecondProcess : FirstProcess
    {

        public override void Calculate(int y, int x)
        {
            Console.WriteLine("Second Process X :{0} and Y :{1}", x, y);
        }
    }

I have called the calculate method like below

  var secondProcess = new SecondProcess();
            var firstProcess = (FirstProcess) secondProcess;

            secondProcess.Calculate(x: 1, y: 2);
            firstProcess.Calculate(x: 1, y: 2);

Output

Second Process X : 1 and Y:2

Second Process X : 2 and Y:1

I got unexpected result that X=2 and Y =1.How .Net handle this scenario? Why .net give priority to named parameter?

Answer 1

Argument binding for the method call firstProcess.Calculate(x: 1, y: 2) is done at compile time , but method dispatch is done at runtime because the method is virtual .

In order to compile the method call, the compiler sees x: 1, y: 2 and needs to resolve this named argument list to a sequentially indexed argument list in order to emit the appropriate IL (push the arguments on the stack in the right order, then call method).

In addition to the named argument list there is one more piece of information available to the compiler: the static type of firstProcess , which is FirstProcess . Now me and you both know that at runtime this is going to be a SecondProcess instance, but the compiler doesn't know that (at least in the general case). So it looks up the parameter list of FirstProcess.Calculate and sees that x is the first argument, y is the second. This makes it compile your code as if you had written

firstProcess.Calculate(1, 2);

At runtime , the arguments 1 and 2 are pushed on the stack and a virtual call is made to Calculate . Of course this ends up calling SecondProcess.Calculate , but the parameter names have not survived the transition to runtime. SecondProcess.Calculate accepts 1 as its first argument ( y ) and 2 as its second argument ( x ), leading to the observed result.

As an aside, this is also what happens when you use default argument values:

public class FirstProcess
{
    public virtual void Calculate(int x = 10)
    {
        Console.WriteLine("First Process  X :{0}", x);
    }
}

public class SecondProcess : FirstProcess
{
    public override void Calculate(int x = 20)
    {
        Console.WriteLine("Second Process  X :{0}", x);
    }
}

var secondProcess = new SecondProcess();
var firstProcess = (FirstProcess) secondProcess;

secondProcess.Calculate(); // "Second Process X: 20"
firstProcess.Calculate();  // "Second Process X: 10"

The moral of the story: named and default arguments are convenient, but the way they are (necessarily) implemented leaves you open to unpleasant surprises. Use them when they offer real tangible benefits, not whenever you can.

Answer 2

When resolving named parameters, the compiler uses the static type of the method being called, not the dynamic type.

Therefore in your example, x refers to the first parameter and y to the second parameter.