CODEWITHSUNDEEP
c#delegateslambda
vc 74
vc 74

Reputation: 38179

Lambda to delegate resolution

I'm currently reading Jon Skeet's C# in depth 2nd edition and the following question came to my mind:

How's the compiler able to choose between list.Sort(Comparison<T>) and list.Sort(MyComparison<T>) in the following example:

// MyComparison has the same signature as Comparison<in T>
public delegate int MyComparison<in T>(T x, T y);

public class MyList<T> : List<T>
{
    // Sort is like Sort(Comparison<T>) except it takes a MyComparison<T> in parameter
    public int Sort(MyComparison<T> comparison)
    {
        Console.WriteLine("Sort MyComparison<T>");
        return -1;
    }
}

MyList<Product> list = new MyList<Product>();

list.Sort((product1, product2) => product1.Name.CompareTo(product2.Name));

// Equivalent to
list.Sort(new MyComparison<Product>((product1, product2) => product1.Name.CompareTo(product2.Name)));

// But not equivalent to...
list.Sort(new Comparison<Product>((product1, product2) => product1.Name.CompareTo(product2.Name)));

Thanks in advance

Upvotes: 2

Views: 642

Answers (2)

Pieter van Ginkel
Pieter van Ginkel

Reputation: 29632

It chooses that one because it's in the child class and it prefers those.

For example:

public class MyList<T> : List<T>
{
    public int Sort2(MyComparison<T> comparison)
    {
    }
    public int Sort2(Comparison<T> comparison)
    {
    }
}

In this case, it doesn't understand anymore and:

list.Sort2((product1, product2) => product1.Name.CompareTo(product2.Name));

and you get an "The call is ambigous" error.

Upvotes: 5

Jon Skeet
Jon Skeet

Reputation: 1499770

If overload resolution comes across an applicable method, it will use that one in preference to any methods declared in base classes. So in this case, it's as if List<T>.Sort didn't even exist, for the first two invocations.

The third invocation isn't applicable, so it will find List<T>.Sort instead.

If you declared another overload for Sort within MyList (but taking Comparison<T> instead of MyComparison<T>) then the method call would be ambiguous.

See my overload resolution article for more details.

PS Hope you're enjoying the book :)

Upvotes: 2

Related Questions