Widening of parameter types for delegates

[ekolis]

If I have a method like so:

public IEnumerable<string> NumbersToStrings(IEnumerable<int?> numbers)
{
    foreach (var num in numbers)
        yield return num?.ToString() ?? "null";
}

And then I want to pass that method as a delegate to another method, say, a LINQ query, but with a more specific parameter type:

var nums = new List<int> {1, 2, 3};
var strings = nums.Select(NumbersToStrings);

Then I get a compile error because nums has a type parameter of int while NumbersToStrings has a type parameter of int?.

But there is an implicit widening conversion from int to int?. So this should not cause an error. Same for conversions from smaller numeric types to larger ones (e.g. int to long), or from derived types to base classes or interfaces (e.g. Human to Creature, or string to object, or Cat to IFurryThing).

There is a workaround of course; just use a lambda expression:

var strings = nums.Select(q => NumbersToStrings(q));

It would be nice though to not have to do that; is there any reason the types have to match exactly?

[osamakawish]

As much as I'd also like an implicit generalization from type T to Nullable<T>, I think you can resolve this issue by changing List<int> to List<int?> in your definition, though correct me if I'm wrong.

---

In general, I guess it might work to always infer A<T1, T2, ... ,Tn> to be a special case of B<S1, S2, ... Sn> whenever A : B (A is a subclass of B) and Ti : Si for all i.

[canton7]

Your question is a little bit confused: NumbersToStrings starts off by accepting an IEnumerable<int?>, and is then used in a context which means it must be declared as accepting an int?, not an IEnumerable<int?>. It's therefore not really clear what you're asking.

---

If you're asking why you can't do...

public void Foo(IEnumerable<int?> input) { ... }

Action<IEnumerable<int>> d = Foo;

The answer here isn't particularly related to delegates. The problem is that a Nullable<int> is larger than an int -- it's got a whole extra bool HasValue property associated with it.

So (regardless of delegates), there's no straightforward conversion from an IEnumerable<int> to an IEnumerable<int?> -- you physically have to take each element in the IEnumerable<int>, allocate storage for an int?, copy the value of the int over, and set that HasValue property to true.

The compiler isn't going to generate code which iterates over your IEnumerable<int> unless you explicitly ask it to, and that's a good thing.

If you start looking at reference conversions however, e.g. from Human to Creature to string to object, this is supported by the compiler and has been since C# 4. You don't need to allocate extra storage here, as all references are the same size. This compiles and works perfectly fine:

using System;
using System.Collections.Generic;
using System.Linq;
					
public class Program
{
	public static void Main()
	{
		var strings = new List<string>() { "a", "b", "c" };
		var objects = strings.Select(ObjectToString);
		Console.WriteLine(string.Join(" ", objects));
	}
	
	public static string ObjectToString(object foo) => foo.ToString();
}

https://dotnetfiddle.net/wpezn2

---

If you're asking why you can't do:

public void Foo(int? x) { }
Action<int> d = Foo;

The answer here is similar: int? and int are different sizes: the compiler needs to insert code which allocates enough space for an int?, copies the contents of the int over, and sets that HasValue property to true.

If you simply write Action<int> d = Foo;, which desugars to Action<int> d = new Action<int>(Foo);, you're explicitly telling the compiler to create a new instance of Action<int> which refers directly to Foo: the delegate's Method property will contain the MethodInfo of the Foo method, guaranteed. There's no way for the compiler to insert that code which allocates the new, extra space that the int? requires.

If however you write Action<int> d = x => Foo(x), you're telling the compiler to create a whole new method which accepts an int and calls Foo. It compiles to something like:

public void Foo(int? x) { }
public void CompilerGeneratedMethod(int x) => Foo(new Nullable<int>(x));

Action<int> d = CompilerGeneratedMethod;

Here, there's no promise that the delegate's Method property will refer to Foo, and the compiler is free to synthesise that intermediate method it needs to turn the int into an int?.

[osamakawish]

The comment said:

But there is an implicit widening conversion from int to int?

Meaning int? x = 5; would be valid code. As per my response, the compiler should be able to infer that List<int> is just a special case of IEnumerable<int?>, since T is covariant in IEnumerable<T>, and int : int? (int implements int?) appears more or less true to me.

[canton7]

Covariance only applies to reference conversions, for the reasons I explained above

[osamakawish]

Ah, whoops. Sorry, I missed that paragraph.