Is it possible to know the element type at compile time without a class implementing IEnumerable?

Question

• summary

  Ignore the case that an object cannot represented as an array, is it possible to define an extension(static) method like:

  public static ? ToArray<TSource>(this TSource source); 
  

  and returns the array of an object if it consists of whatever a sequence of elements? And if yes, what would the ? be?

• explanation

  I've thought about the following declarations:

  public static TElement[] ToArray<TElement>(this IEnumerable<TElement> source); 
  public static ? ToArray<TSource>(this IEnumerable source); 
  

  But I cannot assume an unknown class must have implemented IEnumerable<T> or IEnumerable. I cannot even define the ? in the case it is just IEnumerable which is out of generic definition.

  And I've also thought about the Array class:

  public static Array ToArray<TSource>(this TSource source); 
  

  But that means the element type was unknown at compile time.

  So I'm wondering is it possible to know the element type at compile time without a class implementing IEnumerable<T>?

Answer 1

Unfortunately, IEnumerator predates generics so it carries with it no type information; just a IEnumerator GetEnumerator() making String not so appealing to try and force into this generic implementation you're trying to accomplish.

It's been a long time since I've done C# but I imagine:

public static TElement ToArray<TSource>(this IEnumerable<TElement> source);

... should be fine as:

public static TElement[] ToArray<TElement>(this IEnumerable<TElement> source);

The important thing to keep in mind about extension methods is they are just syntax sugar. They don't actually stick around or become injected into the types they are decorating. They are replaced at compile time to static method invocations. Your mileage with extension methods will vary.

Answer 2

What is your question specifically? If you are asking whether the type of elements in an IEnumerable is always known at compile time, then the answer is "no, it is not always known". The non-generic IEnumerable does not enforce any element type. This is why you can define a foreach loop on any IEnumerable:

IEnumerable items = GetItems();

foreach(SomeClass item in items)
{
   ...
}

but this will throw an InvalidCastException if one of the elements of items cannot be cast to a SomeClass.

Incidentally, if you define a method like this:

public static TElement[] MyToArray<TElement>(this IEnumerable<TElement> source); 

Then you can call it on a string in .NET 2.0+, because string implements IEnumerable<string> in .NET 2.0 and 3.0, and IEnumerable<char> in 3.5+. In fact, the .ToArray() extension that's built into .NET can already be used on string without you defining anything.

Answer 3

It's not known at compile time, and it cannot be known.

For example I could do:

IEnumerable myCollection;
string discriminator = Console.ReadLine();
if (discriminator == "string")
{
   myCollection = new List<string>{"One", "Two", "Three", "Four"};
}
else 
{
   myCollection =  new int[]{1, 2, 3, 4};
}

//what should be the type of the elements variable
var elements = myCollection.ToArray();

Basically, depending on user input, myCollection will be either a List<string> or an int[], two types, that have almost nothing in common, except being enumerable.

So, in order for your ToArray method to work, you can either introduce type safety and generics, using IEnumerable<T> instead of IEnumerable, or use a collection of objects, such as object[] as the return type of your method.