Proposal: Fix generic methods when using out parameters

[ghost]

I had to use code generation for one of my project to be able to serialize types over the network in a particular situation. Eventually some of these types had to be sometimes sent as single element, and sometimes in the form of multiple element. I for that added a generic method

public bool Read(out int b)
{
	// Deserialization ...
	b = 42;
	return true;
}

public bool Read<T>(out List<T> b)
{
	b = new List<T>();
	for (var i = 0; i != 50; ++i)
	{
		if (false == Read(out T c))
			return false;

		b.Add(c);
	}

	// Compilation fails.
	// Error CS1503: cannot convert from 'out T' to 'out int'
	return true;
}

public void Write(int b)
{
	// Serialization ...
}

public void Write<T>(IReadOnlyList<T> b)
{
	for (var i = 0; i != b.Count; ++i)
		Write(b[i]);

	// Compilation fails.
	// Error CS1503: cannot convert from 'T' to 'int'

	// Resharper suggests creating an overload
	// If you write an overload for 'Write' with as parameter 'object b'
	// it will compile, but this method will always call the overload for object
	// despite T being 'int'.
}

I ended up adding up a special pass to my code generator to generate serialization extensions in the special use of List per type, which creates the unnecessary need of having to perform one more code generation if you suddenly need to serialize a list of a certain type. (and would create unnecessary code if it was generated for all types by default even when it's not needed)

[HaloFour]

Generics don't work like templates. They don't specialize at compile time and they cannot take overloads into consideration. You'd need a generic single-item method which would internally specialize based on the generic type argument:

public bool Read<T>(out T b)
{
    if (typeof(T) == typeof(int)) {
        bool result = Read(out int temp);
        b = (T)(object)temp;
        return result;
    }
    b = default(T);
    return false;
}

Generates some pretty awful IL but IIRC the JIT will produce optimized versions for value types.