Which overloaded methods are added to the delegate?

Question

The following is a question I've seen on a test which raised some questions:

Given the following code:

public delegate B func(B b);

public class A
{
    public func x;
    public int i = 2;
    public A(int i) { this.i = i; x += f; }
    public virtual C f(A a) { Console.WriteLine("C A.f(A)"); return new C(1); }
    public virtual A f(C c) { Console.WriteLine("A A.f(C)"); return new A(2); }
}

public class B: A{
    public B(int i) : base(i) { x += f; }
    public virtual B f(B b) { Console.WriteLine("B B.f(B)"); return new B(3); }
    public new C f(A a) { Console.WriteLine("C B.f(A)"); return new C(4); } 
}

public class C: B{
    public C(int i) : base(i) { x += f; }
    public new B f(B b) { Console.WriteLine("B C.f(B)"); return new C(5); }
    public override A f(C c) { Console.WriteLine("A C.f(C)"); return new A(6); }
}

with the following main:

static void Main(string[] args)
{
    C c = new C(12);
    A a = c.x(c);
    Console.WriteLine(a.i);
}

1. What is the output?
2. What happens if we change the delegate definition to: public delegate C func(B b);
3. What happens when we change the delegate definition to public delegate T func<T,U>(U u); and change x in A to public func<B,B> x;?

The official answers were:

To #1:

C A.f(A)
B B.f(B)
B C.f(B)
5

To #2:

It won't compile because the method that are added to x in class B and C are chosen based on the static type of the argument. So in class B B B.f(B) needs to be added but the return type doesn't match, and in class C B C.f(B) needs to be added but the return type doesn't match.

To #3:

It prints the same answer as #1 since both definitions are equivalent.

Here is what I don't understand:

1. How are the methods which are added to x in the line x+=f; chosen out of all the overloaded options? Is the overloaded method with the "closest" argument type to the dynamic type of "this" the one chosen?
2. Aren't generic delegates non variant unless declared with in and out? How does the answer to #3 make sense?

Answer 1

Is the overloaded method with the "closest" argument type to the dynamic type of "this" the one chosen?

No. If that were true, then all constructors would choose the same method (B C.f(B)), because it matches exactly and is in the most derived type. Instead, the static type of this is used.

This means that:

1. In A, C A.f(A) is chosen, because it's the only method on A that matches func.
2. In B, B B.f(B) is chosen, because it's the only method on B that matches perfectly.
3. In C, B C.f(B) is chosen, because it matches perfectly and is declared in a more derived type than B B.f(B).

Aren't generic delegates non variant unless declared with in and out?

Yes, such delegates are invariant, which means that you can't convert func<B, B> to func<A, B>, func<B, C> or func<A, C>. But it doesn't change the rules of converting from method groups to delegates, which allow similar conversions, no matter whether the delegate type is generic or not.