Does C# compiler hardcode a special processing for IEnumerable?

Question

As an example use the Join() method from class String. When you call it on a byte array, e.g.

 byte[] bytes = {3,4,5};
 string str = string.Join(",", bytes);

C# compiler maps Join to this signature

 public static String Join<T>(String separator, IEnumerable<T> values);

However, byte[] derives implicitly from class Array which does not derive from the generic IEnumerable, instead it derives from the non-generic IEnumerable, i.e.

 public abstract class Array : ICloneable, IList, ICollection, IEnumerable, IStructuralComparable, IStructuralEquatable {...}

If I do the same with my own interfaces and class that resemble this case, I will get a compiler error as expected because according to the rules you cannot cast a class deriving from an interface IA (non-generic IEnumerable) into an interface IB (generic IEnumerable) that derives from IA. This means that C# compiler simply hardcodes the specific name IEnumerable. Where is this explained?

Answer 1

However, byte[] derives implicitly from class Array which does not derive from the generic IEnumerable, instead it derives from the non-generic IEnumerable, i.e.

True, but byte[] implements IEnumerable<byte> itself, which makes perfectly sense. I guess that is a compiler feature on compiling a specific type for Foo[] (so everything deriving from Array basically).

See the implemented interfaces on byte[] (obtained using Type t = typeof(byte[]);, see property ImplementedInterfaces):

The first 6 interfaces are probably from Array, the last 5 interfaces are the generic versions of 1-6.

Answer 2

Array is special in the CLR. In particular only reference type arrays are covariant. Value types such as byte are not. That's just the way it is. Eric Lippert did a blog post on this a decade ago.

Of the available options for String.Join the only version that matches byte[] is String Join<T>(String, IEnumerable<T>)

byte[] can not be converted to string[], object[] or IEnumerable<string>.

Available options...

String Join(String, IEnumerable<String>) 
String Join(String, Object[])
String Join(String, String[]) 
String Join(String, String[], Int32, Int32) 
String Join<T>(String, IEnumerable<T>)

Example of type errors ...

object[] test1 = new byte[0];
string[] test2 = new byte[0];
IEnumerable<string> test3 = new byte[0];
IEnumerable<byte> test4 = new byte[0];

... compiler errors for above ...

Cannot implicitly convert type 'byte[]' to 'object[]'
Cannot implicitly convert type 'byte[]' to 'string[]'
Cannot implicitly convert type 'byte[]' to  to 'System.Collections.Generic.IEnumerable<string>' 

More Conversion examples

Foo[] test = new OtherFoo[0]; // allowed
OtherFoo[] test = new Foo[0]; // not allowed

public class Foo
{
}
public class OtherFoo : Foo
{
}