[Proposal]: LINQ function support for dynamic object

[qhc99]

FEATURE_NAME

LINQ function support for dynamic object

• Proposed
• Prototype: Not Started
• Implementation: Not Started
• Specification: Not Started

Summary

LINQ function cannot be applied to dynamic object, which is contrary to intuition.

Motivation

congruent disign

Detailed design

public static class Program
    {
        public static void Main()
        {
            List<int> l = new List<int> {1, 2, 3};
            l = l.Skip(1).ToList();
            // error below
            dynamic t = new List<int> {1, 2, 3};
            t = t.Skip(1).ToList();
        }

    }

Unhandled exception. Microsoft.CSharp.RuntimeBinder.RuntimeBinderException: 'System.Collections.Generic.List<int>' does not contain a definition for 'Skip'
   at CallSite.Target(Closure , CallSite , Object , Int32 )
   at System.Dynamic.UpdateDelegates.UpdateAndExecute2[T0,T1,TRet](CallSite site, T0 arg0, T1 arg1)
   at .Program.Main() in Program.cs:line 17

Drawbacks

No drawback in semantics.

Alternatives

It seems that the only solution is type casting.
Answers from StackOverflow (https://stackoverflow.com/questions/18734996/how-to-use-linq-with-dynamic-collections/18735033) do not work in .Net 5.

Unresolved questions

Design meetings

[HaloFour]

At runtime there is no way to know which extension methods were in scope, so the runtime binder would have no idea what Skip method you're trying to call.

[qhc99]

Put performance cost aside, I think it is possible in "theory". List<T> extends IEnumberable<T> and the first 'this' parameter of Skip function is IEnumerable<T>. If LINQ functions information was included in reflection, it could be easily determined which Skip functions the code is calling, but I didn't find an attribute or method of Type class that related to LINQ functions. (The code below is got from offical library by dotPeek.)

  public class List<T> : 
    IList<T>,
    ICollection<T>,
    IEnumerable<T>,
    IEnumerable,
    IList,
    ICollection,
    IReadOnlyList<T>,
    IReadOnlyCollection<T>
  {
  ...

   public static IEnumerable<TSource> Skip<TSource>(
      this IEnumerable<TSource> source,
      int count)
    {
    ...

By the way, in terms of name confusion, I had an small experiment.

    public static class Program
    {
        public static void Main()
        {
            var l = new List<int>();
            l.Method();
        }

        public static void Method<T>(this ICollection<T> a)
        {
            Console.WriteLine("ICollection");
        }

        public static void Method<T>(this IEnumerable<T> a)
        {
            Console.WriteLine("IEnumerable");
        }
    }

Output:

ICollection

It seems that it determines by inheritance order. In a word, I guess LINQ function support for dynamic object could be implemented if there was support for LINQ reflection.

[HaloFour]

In a word, I guess LINQ function support for dynamic object could be implemented if there was support for LINQ reflection.

Extension methods don't exist at runtime. They are static methods that can exist anywhere, and which static method should be used is based entirely on which namespaces you imported into the current file and in which order. That namespace information is completely lost at runtime. The closest you would get is to scan every single method in every single assembly looking for any method that might accept the target type as the first parameter. Apart from being very slow you also would not be able to eliminate ambiguities based on the namespace of the static class.