Is method overloading polymorphism Early Bound in C#?

Question

In C#, if I have

public class BaseClass
{
    //BaseClass implementation
}

public class Derived : BaseClass
{
    //Derived implementation
}

public class AnotherClass
{
    AnotherClass(BaseClass baseClass)
    {
        //Some code
    }

    AnotherClass(Derived derived) : this(derived as BaseClass)
    {
        //Some more code
    }
}

and then do:

BaseClass    baseVariable    = new Derived();
AnotherClass anotherVariable = new AnotherClass(baseVariable);

This will lead to early binding, calling the AnotherClass(BaseClass) method.

Instead, if I cast it using dynamic keyword - or instantiate a variable with dynamic and then pass it as constructor argument, the AnotherClass(Derived) will be invoked:

BaseClass    baseVariable    = new Derived();
//This will instantiate it using the AnotherClass(Derived)
AnotherClass anotherVariable = new AnotherClass(baseVariable as dynamic);

Is method overloading early bound (Evaluated at compile time) in C#? That meaning, is there any other way or trick ~~to determine the mostly-derived call to the other class constructor~~ to apply the invocation of the constructor that takes the mostly derived class type as argument in my case without the use of dynamic or reflection?

You're not instantiating `AnotherClass` anywhere, so I don't see how the second snippet is relevant. — Asad Saeeduddin, Dec 14 '15 at 15:51
Note that `new AnotherClass(base as dynamic)` won't even compile, as `base` isn't a valid expression on its own. — Jon Skeet, Dec 14 '15 at 15:55
Not sure what you mean by "determine the mostly-derived call to the other class constructor". To put it a different way - is there anything my answer doesn't cover at the moment? — Jon Skeet, Dec 14 '15 at 17:14
I rephrased the last part of the question for better understanding purposes from future viewers, but I think the question is answered in completeness. Thank you @JonSkeet. — Nick Louloudakis, Dec 14 '15 at 17:23

Jon Skeet · Accepted Answer · 2015-12-14T17:13:44.387

The binding time in C# depends on whether the binding involves dynamic or not. As you've seen, if you use dynamic you get execution-time overload resolution; if you don't, you get compile-time overload resolution.

Note that even when overload resolution involves dynamic typing, it will still use the information known at compile-time - only the expressions which are of type dynamic use the execution-time type. Example of that:

using System;

class Test
{
    static void Main()
    {
        object x = "abc";
        dynamic y = 10;

        Foo(x, y); // Prints Foo(object,int)
    }

    static void Foo(object x, int y)
    {
        Console.WriteLine("Foo(object,int)");
    }

    static void Foo(string x, int y)
    {
        Console.WriteLine("Foo(string,int)");
    }
}

If you change the declared type of x to dynamic, then the execution-time type will be relevant (and it will print Foo(string,int)).

Of course, this is only overload resolution - overriding is always determined at execution time, unless you're using a non-virtual invocation (either invoking a non-virtual method, or using base.Foo(...).

"Is method overloading early bound (Evaluated at runtime) in C#? " - this was a typo, my intention was to write about compile time, my apologies. — Nick Louloudakis, Dec 14 '15 at 17:13
@NickL.: That's unfortunate :) Have edited that bit out of my answer. — Jon Skeet, Dec 14 '15 at 17:13

score 1 · Answer 2 · answered Dec 14 '15 at 16:03

Regarding this bit:

Is there any other way or trick to determine the mostly-derived call to the other class constructor - apart reflection?

The only way to find out the most derived type of the object stored in a reference is to interrogate it (using GetType or whatever). So no, reflection is unavoidable here.

If you already know what the most derived type is, you can of course cast to it before passing in, so that the appropriate overload is chosen at compile time. You could also have used var in your first snippet to automatically use the most derived type for the reference.

Thank you for your answer, as it is a very nice addition to Jon Skeet's answer. — Nick Louloudakis, Dec 14 '15 at 17:23

Is method overloading polymorphism Early Bound in C#?

2 Answers2