IEnumerable to array of T[]

Question

Perhaps the question title is incorrect. I have the following variables

IEnumerable x = // some IEnumerable
System.Type y = // some type

How can iterate over x in order to generate an array with items of type y?

When I look into the internet I found:

public T[] PerformQuery<T>(IEnumerable q)
{                         
        T[] array = q.Cast<T>().ToArray();
        return array;
}

Note I cannot call that method PerformQuery becuase y is of type System.Type in other words calling it as PerformQuery<typeof(y)>(x); or PerformQuery<y>(x); will give me a compiler error.

edit

Here is the reason why I have that problem. I have web service where I post to it two things. The type of table I will like to query (example typeof(Customer)), and the actual string query example "Select * from customers"

    protected void Page_Load(object sender, EventArgs e)
    {
        // code to deserialize posted data
        Type table = // implement that here
        String query = // the query that was posted

        // note DB is of type DbContext
        IEnumerable q = Db.Database.SqlQuery(table, query );

        // here I will like to cast q to an array of items of type table!

Why do you want to do this? Unless you have a known compile-time type, this isn't going to be all that useful (unless I'm missing something). — spender
– spender, Commented Feb 20, 2014 at 21:46

MarcinJuraszek · Accepted Answer · 2014-02-20 22:16:16Z

6

You can use Expression Trees:

public static class MyExtensions
{
    public static Array ToArray(this IEnumerable source, Type type)
    {
        var param = Expression.Parameter(typeof(IEnumerable), "source");
        var cast = Expression.Call(typeof(Enumerable), "Cast", new[] { type }, param);
        var toArray = Expression.Call(typeof(Enumerable), "ToArray", new[] { type }, cast);
        var lambda = Expression.Lambda<Func<IEnumerable, Array>>(toArray, param).Compile();

        return lambda(source);
    }
}

It generates x => x.Cast<Type>().ToArray() for you, with Type known at runtime.

Usage:

IEnumerable input = Enumerable.Repeat("test", 10);
Type type = typeof(string);

Array result = input.ToArray(type);

edited Feb 20, 2014 at 22:16

answered Feb 20, 2014 at 22:09

MarcinJuraszek

126k15 gold badges200 silver badges267 bronze badges

Sign up to request clarification or add additional context in comments.

3 Comments

Fede Over a year ago

How is this different from my answer? the Array result is still of unknown type, isn't it? looks like you're overcomplicating it with no extra benefit

Tono Nam Over a year ago

+1 thanks a lot. How can I get the inner array of System.Array so that I return an object of type dynamic[] instead of System.Array

MarcinJuraszek Over a year ago

You can just cast it to dynamic[]: (dynamic[])result

user2864740 · Accepted Answer · 2014-02-20 21:52:19Z

5

var ObjectsOfType_y = x.OfType<object>().Where(x => x.GetType() == y);

Notice that this will return an IEnumerable<object>, though. There's no way around that because the type that y (Type) represents is unknown at compile time.

edited Feb 20, 2014 at 21:52

user2864740

62.5k15 gold badges159 silver badges234 bronze badges

answered Feb 20, 2014 at 21:46

Fede

44.2k11 gold badges104 silver badges156 bronze badges

1 Comment

MarcinJuraszek Over a year ago

How did IEnumerable<object> become an answer for I need T[] question?

Jeter · Accepted Answer · 2016-08-10 14:33:13Z

0

According to my understanding, IENumerable contains only one type. If I understand what you're trying to do, IENumerable already only contains only objects of type y. If y needs to change, you can write an extension method:

public static T[] ToArray<T>(this IEnumerable<T> source)
    {
        int length = System.Linq.Enumerable.Count(source);
        T[] newArray = new T[length];
        int i = 0;
        foreach(T item in source)
        {
            newArray[i] = item;
        }
        return newArray;
    }

answered Aug 10, 2016 at 14:33

Jeter

92 bronze badges

1 Comment

CajunCoding Over a year ago

This does not address the original question of casting to a different type using the Type variable at runtime; this only works for generic type parameters at compile time to convert to an array of the exact same type.

CajunCoding · Accepted Answer · 2024-10-16 19:45:23Z

While the accepted answer here is good and has no dependencies it can have some significant performance impacts as it compiles the expression on every execution.

And if you you are doing reflection operations like this then you should probably be using a nice library like Fasterflect to greatly simplify as well as provide huge performance improvements by encapsulating the complexities of caching, expression building/compiling, etc.

So using Fasterflect this can be done pretty easily with some extension methods such as:

public static class TypeCache
{
    public static readonly Type StringType = typeof(string);
    public static readonly Type EnumerableType = typeof(Enumerable);
}

public static IEnumerable Cast(this IEnumerable source, Type outputType)
    //NOTE: Cast<TResult>() is an extension method that is actually defined on the Enumerable static class which is how we need to reference it...
    => (IEnumerable)TypeCache.EnumerableType.CallMethod(genericTypes: [outputType], name: nameof(Enumerable.Cast), source);

public static Array ToArray(this IEnumerable source, Type outputType)
    => source is not null
        //NOTE: ToArray<TSource>() is an extension method that is actually defined on the Enumerable static class which is how we need to reference it...
        ? (Array)TypeCache.EnumerableType.CallMethod(genericTypes: [outputType], name: nameof(Enumerable.ToArray), source.Cast(outputType))
        : null;

public static IList ToList(this IEnumerable source, Type outputType)
    => source is not null
        //NOTE: ToArray<TSource>() is an extension method that is actually defined on the Enumerable static class which is how we need to reference it...
        ? (IList)TypeCache.EnumerableType.CallMethod(genericTypes: [outputType], name: nameof(Enumerable.ToList), source.Cast(outputType))
        : null;

Usage of this is now very very simple....

//Contrived example where you have two classes MyClass and MySubClass, which inherits from MyClass...
var list = new List<MyClass> { new(1), new(2), new(3) };
var objectEnumerable = (IEnumerable)intList.Select(i => (object)i);

subClassType = typeof(MySubClass);
//Usage
var subClassEnumerable = objectEnumerable.Cast(subClassType);
//or
var subClassArray = objectEnumerable.ToArray(subClassType);
//or
var subClassList = objectEnumerable.ToList(subClassType);

Also available in my Gist here: https://gist.github.com/cajuncoding/c02c5161da146f047df579273cdb4df6

nawfal · Accepted Answer · 2023-04-10 04:57:02Z

-1

This is a lot simpler if you use C#'s dynamic dispatch, using the dynamic keyword. You dont even need fancy methods or, even the Type you have. You can directly use your method. So if you have

public T[] PerformQuery<T>(IEnumerable<T> q)
{                         
        T[] array = q.ToArray();
        return array;
}

Just call

IEnumerable x = // some IEnumerable
dynamic y = x;
IEnumerable z = PerformQuery(y);

answered Apr 10, 2023 at 4:57

nawfal

73.8k59 gold badges342 silver badges379 bronze badges

2 Comments

CajunCoding Over a year ago

This does not address the original question of casting to a different type using the Type variable at runtime; this only works for generic type parameters at compile time to convert to an array of the exact same type.

nawfal Over a year ago

This does address the exact problem OP is facing, which is not being able to call PerformQuery method because it is generic. If you want to cast to a different type (like you say), which is not the question, then that depends on your definition of casting. Representation changing casting can be done (with methods like ConvertType though it is a very different thing). OP merely wants a representation preserving casting (where he doesnt know the type at compile time).

Collectives™ on Stack Overflow

IEnumerable to array of T[]

edit

5 Answers 5

3 Comments

1 Comment

1 Comment

Comments

2 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

edit

5 Answers 5

3 Comments

1 Comment

1 Comment

Comments

2 Comments

Your Answer

Sign up or log in

Post as a guest

Related