CLR如何解决涉及动态类型的方法？

Question

Given,

Method overloading = compile time resolution.

Method overriding = run-time resolution.

How does CLR resolve the following method call (involving a dynamic type) ?

    dynamic intValue = -10;
    var result = Math.Abs(intValue);

Thanks for your interest.

Answer 1

The process of connecting names to what they are is called binding . Normal overload resolution is 'early' binding, because the exact meaning of the method name is determined early - at compile time.

When the compiler encounters a virtual method during overload resolution, it emits a virtual call. At runtime, this is routed to the correct method, possibly to an override.

When the compiler encounters a dynamic object, it emits code to perform 'late' binding, ie at runtime. Late binding is like overload resolution at runtime. The code looks at the argument, finds out its an integer, looks up the correct overload to call, and calls it.

Well, it actually does a bit more than that. It caches the result of the lookup and puts in a test so that the next time the code is run, it can go right to calling the correct method if the argument type is int .

This is still a simplification. In reality, several more optimizations may be done to gain optimal performance.

See this blog post for a more thorough explanation of exactly what would happen with your example.

Answer 2

Method binding that involves dynamic type parameters is a bit tricky in C#. The first and basic rule the compiler uses is: Types take precedence over dynamic. for example:

void method(dynamic x, string y)
    {
        //do something 
    }

    void method(int x, string y)
    {
        // do something 
    }

a call to the method with arguments int and string method(5,"some string) would be resolved to the second function. However if the parameters of either of the methods were both dynamic the compiler would complain about ambiguous method call.