Why a dynamic item, when passed to a method, the method's return type is not validated by the compiler?

In C#, in a for loop returning a dynamic item, when the item is passed into a method, the method's return type is not validated by compiler, when assigning the result to an incompatible typed variable.

NOTE: There is a similar question but that relates to changing the return type, whereas here we focus on compiler type checking, an important difference on Google searches.

Better explained in the example below, why is the compiler not raising a type conversion error?

void Main()
{
   List<dynamic> vals = new List<dynamic>(100);
   for (int i = 0; i < 100; i++) vals.Add(new { Id = i});
   
   foreach (dynamic itm in vals)
   {
      //no compile error, why?? result should be an int, as GetId returns an int!
      string result = GetId(itm);
      Console.WriteLine($"id: {result}");     
   }

   //id2 must be an int, else compile error
   int id2 = GetId(new {Id = 100});
}

public static int GetId(dynamic b)
{
   return b.Id;
}

The above compiles, but will result in a runtime error, naturally this runtime error is expected.

> HResult -2146233088
InnerException null
Message Cannot implicitly convert type 'int' to 'string'

From section 11.3.1 of the C# standard:

> However, if an expression is a dynamic expression (i.e., has the type dynamic) this indicates that any binding that it participates in should be based on its run-time type rather than the type it has at compile-time. The binding of such an operation is therefore deferred until the time where the operation is to be executed during the running of the program. This is referred to as dynamic binding.

That "any binding that it participates in" means that any time you call a method with a dynamic argument (or on an expression of type dynamic), the result of that call is also dynamic.

The compiler will validate that there's a GetId method which can be called with the number of arguments you're providing, but it doesn't do any overload resolution beyond that - which means it doesn't try to work out the potential set of return types.

For example, suppose your actual code was:

public static int GetId(int b) => b;
public static string GetId(string c) => c;

... your calling code would still compile, and the right overload would be picked at execution time, but the compiler can't tell you whether you'll get a string or an int back.

Rather than trying to provide more information in the simpler case, the language rules basically say "Nope, you're in a dynamic world now - we're not going to go half way."

The dynamic type is a static type, but an object of type dynamic bypasses static type checking. In most cases, it functions like it has type object. The compiler doesn't give you a warning because it assumes a dynamic element supports any operation.

dynamic is fully run-time thing by its nature. Only minimal compile-time checks are performed (e.g. the method with desired name exists and and it can be called with desired number of arguments (1 argument in this case)). Compiler even does not generate a real function call here, it generates instructions which will create a real calling code in run-time depending on real contents of dynamic variable. So, your string text = GetId(itm); compiles into something like this

if (<>o__0.<>p__1 == null)
{
    <>o__0.<>p__1 = CallSite<Func<CallSite, object, string>>.Create(Microsoft.CSharp.RuntimeBinder.Binder.Convert(CSharpBinderFlags.None, typeof(string), typeof(C)));
}
Func<CallSite, object, string> target = <>o__0.<>p__1.Target;
CallSite<Func<CallSite, object, string>> <>p__ = <>o__0.<>p__1;
if (<>o__0.<>p__0 == null)
{
    Type typeFromHandle = typeof(C);
    CSharpArgumentInfo[] array = new CSharpArgumentInfo[2];
    array[0] = CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.UseCompileTimeType, null);
    array[1] = CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null);
    <>o__0.<>p__0 = CallSite<Func<CallSite, C, object, object>>.Create(Microsoft.CSharp.RuntimeBinder.Binder.InvokeMember(CSharpBinderFlags.InvokeSimpleName, "GetId", null, typeFromHandle, array));
}
string text = target(<>p__, <>o__0.<>p__0.Target(<>o__0.<>p__0, this, arg));

In code above

• C is your class type (this)
• arg is itm

So, in this code there is no types known in compile-time at all. It will be fully resolved only in compile-time.

And finally, all above were implementation details. And the language standard (11.3.1 "General") says the following

> However, if an expression is a dynamic expression (i.e., has the type
> dynamic) this indicates that any binding that it participates in
> should be based on its run-time type rather than the type it has at
> compile-time. The binding of such an operation is therefore deferred
> until the time where the operation is to be executed during the
> running of the program. This is referred to as dynamic binding.
>
> When an operation is dynamically bound, little or no checking is
> performed by the compiler. Instead if the run-time binding fails,
> errors are reported as exceptions at run-time.