How Default Parameter Works When It Comes Overload Method

As everybody may already know, Default Parameter is a new feature comes from .NET 4, but I would like to show some code snippets to demo how it works in overload method.

So let’s start write some code here, I am trying to use default parameter every where in this demo, it may doesn’t make any sense at all, just for demo purpose:

public class Foo
    {
        private int x, y;

        public Foo(int x = 1, int y = 2)
        {
            this.x = x;
            this.y = y;
        }

        public void PrintOut()
        {
            Console.WriteLine("x is {0}, y is {1}", x, y);
        }

        public void PrintOut(int x = 5)
        {
            Console.WriteLine("x is {0}, this is being called from single parameter method:PrintOutMethod", x);
        }

        public void PrintOut(int x = 5, int y = 6)
        {
            Console.WriteLine("x is {0}, y is {1}, this is being called from two parameter method", x, y);
        }
    }

So the caller using some code like this:

            var Foo = new Foo();

            Foo.PrintOut();
            Foo.PrintOut(50);
            Foo.PrintOut(x: 60);
            Foo.PrintOut(y: 60);

No surprise, the result comes out:

Looks like C# compiler using its best guess, if caller pass in one value, it doesn’t matter if it is explicit the parameter’s name or not, it will call the fittest method.

So, Basically, I think named parameter provides a lots of convenience, but like everything else It may brings some confusion when using it reckless in the code.

Homework:

You may try another kind of overload method, like DoMath(int a),  DoMath(double a), DoMath<T>(T a) and call it with DoMath(2), guess which one is pops up~

As a matter of fact, we can do a lot of fun stuff with generic type, you can comment out another single parameter method, and add

       public void PrintOut<T>(T x)
        {
            Console.WriteLine("x is {0}, this is being called from generic parameter method", x);
        }

And after you tried out, maybe change the “x” parameter name to another one, like “y”, then call again, see what is gonna happen, very interesting.

Another interesting thing about named parameter is built two calsses, and use virtual and override method in them, something like below and test it out.

public class BaseClass
    {
        public virtual void Calculate(int y, int x)
        {
            Console.WriteLine("The x: {0}, y:{1} from base class", x, y);
        }
    }

    public class SubClass : BaseClass
    {
        public override void Calculate(int x, int y)
        {
            Console.WriteLine("The x: {0}, y:{1} from Man class", x, y);
        }
    }

The caller use named parameter to call this.

The reason is C# assign those value at compile time, when comes to base class, it remember y’s position in the first palace, and when the program actually running, the sub class’s method will run, and assign Y to Subclass’s X.