Add explanation for anonymous function about contravariant

[LeaFrock]

It's counterintuitive and seems there isn't any doc about it. I find a answer related to it on SO.

I think it deserves adding extra explanation at this page.

See the example below,

    class Program
    {
        private static void Main()
        {
            var personReadContact = (Person p) => p.ReadContact();

            // OK
            Action<Employee> employeeReadContact = personReadContact;

            // Compile error: CS1661
            // Action<Employee> employeeReadContact = (Person p) => p.ReadContact();
        }
    }

    public class Person
    {
        public virtual void ReadContact() { /*...*/ }
    }

    public class Employee : Person
    {
        public override void ReadContact() { /*...*/ }
    }

---

Document Details

⚠ Do not edit this section. It is required for learn.microsoft.com ➟ GitHub issue linking.

• ID: 61dc3fdf-0154-aa6b-50f4-eb85b5079b05
• Version Independent ID: 0e7cf4e1-1b69-7800-b949-02d60672d396
• Content: Using Variance for Func and Action Generic Delegates (C#)
• Content Source: docs/csharp/programming-guide/concepts/covariance-contravariance/using-variance-for-func-and-action-generic-delegates.md
• Product: dotnet-csharp
• Technology: csharp-advanced-concepts
• GitHub Login: @BillWagner
• Microsoft Alias: wiwagn

[BillWagner]

Hi @LeaFrock

I agree, this is counter-intuitive.

Adding @cston for clarification. I don't think this is related to contravariance. Rather, I think it's related to the updated type inference rules for anonymous functions.

[LeaFrock]

I don't think this is related to contravariance

I don't mean it's the problem of contravariance. But it's indeed a very typical case to show a special side of lambda.

... for clarification

Thanks. I think it's also meaningful to add this case here, since this page talks about a very common type Action<in T> which is a lot possible for helping beginners learn about what makes anonymous function special.

[cston]

I don't know the specific reasons why variance is not supported for implicit conversions from lambda expressions to delegates.
But variance seems less necessary for an implicit conversion from lambda to delegate (than with conversions between delegate types) because typically the lambda signature can be modified to match the delegate.

Note also that the first case in the example above is essentially the following, which is valid.

Action<Employee> employeeReadContact = new Action<Person>((Person p) => p.ReadContact());

[LeaFrock]

But variance seems less necessary for an implicit conversion from lambda to delegate (than with conversions between delegate types) because typically the lambda signature can be modified to match the delegate.

It's an explanation enough for beginners. Even a single sentence with this case, like variance is not supported for implicit conversions from lambda expressions to delegates, is enough.

And it'd be better if you can add a reference of the deep reason. I think it will solve the confusion of beginners and is also a high probability to make them more interested in C#.

[BillWagner]

Thanks @LeaFrock

That's a great suggestion. I've added it to our backlog to address when I next update this area.