Delegate Conversions

[TonyValenti]

Aren't all delegates with matching parameter types supposed to be convertable to each other?

If so, why is it that V1 and V2 aren't equivalent? And how are they different?

namespace ConsoleApp4 {
    internal class Program {

        private delegate IAsyncEnumerable<string> InvokeMethod1(string ConnectionString, string ConnectionType, CancellationToken Token);
        private delegate IAsyncEnumerable<T> InvokeMethod2<T>(string ConnectionString, string ConnectionType, CancellationToken Token);

        static void Main(string[] args) {

            var Methods = GetMethods();
            var V1 = Methods.OfType<Func<string, string, CancellationToken, IAsyncEnumerable<string>>>().ToList();
            var V2 = Methods.OfType<InvokeMethod2<string>>().ToList();
            var V3 = Methods.OfType<InvokeMethod1>().ToList();

            if (V1.Count != V2.Count) {
                Console.WriteLine("Something is not right");
            }

        }

        static void Test1() {
        }

        static void Test2() {
            
        }

        static async IAsyncEnumerable<string> Test3(string Input1, string Input2, CancellationToken Token) {
            yield break;
        }


        static List<Delegate> GetMethods() { 
            var ret = new List<Delegate>()
            {
                Test1,
                Test2,
                Test3,
            };

            return ret;

        }

    }
}

[HaloFour]

Aren't all delegates with matching parameter types supposed to be convertable to each other?

No, delegates are nominal types and not convertible between each other regardless of their signature. The natural type for a method group will be one of the Action<...> or Func<...> delegate families if compatible, otherwise the compiler will emit a compatible delegate type with an unspeakable name. That is why V1 contains a single method, the natural delegate type for method Test3 is Func<string, string, CancellationToken, IAsyncEnumerable<string>>. But even though that delegate has the same signature as InvokeMethod1 and InvokeMethod2 it is not considered the same type and cannot be cast to those types. The closest you can get to that is to take a new delegate that points to the Invoke method of the existing delegate, since they have compatible signatures.