ADL

[Tobias M via Digitalmars-d]

On Saturday, 3 September 2016 at 12:40:26 UTC, ZombineDev wrote:
> No, LINQ doesn't work because of interfaces, but because of 
> extension methods (C#'s variant of UFCS). The IEnumerable<T> 
> interface defines only a single method. All the useful 
> functionality is implemented as extension methods which are 
> only available if the user specifically imports the namespace 
> in which where they're defined (just like D's ranges and range 
> primitive implementations for arrays). Those extension methods 
> are used as a fallback, similarly to UFCS in D: every type can 
> override the extension methods by implementing the method 
> itself. Also more inner namespaces (more closer to the method 
> invocation) override more outer namespaces.

I know extension methods, that's not the point.
The point is, that you cannot have a generic method like this in 
C#, it won't compile:

class Bar
{
     void GenericMethod<T>(T arg)
     {
         arg.Foo();
     }
}

Instead you need a constraint like this:

interface IFoo
{
     void Foo();
}

class Bar
{
     void GenericMethod<T>(T arg) where T: IFoo
     {
         arg.Foo();
     }
}

Similarly for LINQ, you cannot just implement a generic "Sum" 
extension method for IEnumerable<T> that works for all T, because 
you cannot just use the + operator in that method. It is not 
defined on T if there are no respective constraints.

Look at how it is implemented separately for every type T that 
supports +:
https://msdn.microsoft.com/de-de/library/system.linq.enumerable.sum(v=vs.110).aspx